package mandreelFile5;
/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import static Class.CommonClassFile.commonVariable;
import static Class.CommonClassFile.heapClassInst;
import static Class.DevNumber.*;
import static commonFile.CommonFile.*;
import static commonFile.SwriteIndex.swriteIndex;

public class mandreelFile5 {
    
    public static void znk17btTypedConstraint9serializeEPvP12btSerializer(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine2];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[fp];
        r3 = heapClassInst.heap32[r1];
        r3 = r3 >> numDefine2;
        r4 = r2 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine7];
        r5 = heapClassInst.heap32[r4 + numDefine5];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r5;
        r5 = heapClassInst.heap32[fp + 1];
        functionTable.get(r3 >> numDefine2).accept(i7);
        r5 = r5 >> numDefine2;
        heapClassInst.heap32[r5] = commonVariable.rg0;
        r3 = heapClassInst.heap32[r1];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine7];
        r6 = heapClassInst.heap32[r4 + numDefine6];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r6;
        functionTable.get(r3 >> numDefine2).accept(i7);
        heapClassInst.heap32[r5 + 1] = commonVariable.rg0;
        r3 = heapClassInst.heap32[r1];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine10];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        functionTable.get(r3 >> numDefine2).accept(i7);
        r3 = commonVariable.rg0;
        r6 = heapClassInst.heap32[r1];
        r6 = r6 >> numDefine2;
        r6 = heapClassInst.heap32[r6 + numDefine7];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r3;
        functionTable.get(r6 >> numDefine2).accept(i7);
        r6 = commonVariable.rg0;
        heapClassInst.heap32[r5 + numDefine2] = r6;
        if (!(r6 == 0)) {
            r1 = heapClassInst.heap32[r1];
            r1 = r1 >> numDefine2;
            r1 = heapClassInst.heap32[r1 + numDefine12];
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r3;
            functionTable.get(r1 >> numDefine2).accept(i7);
        }
        r0 = heapClassInst.heap32[r4 + 1];
        heapClassInst.heap32[r5 + numDefine3] = r0;
        r0 = heapClassInst.heapU8[r2 + numDefine16];
        heapClassInst.heap32[r5 + numDefine6] = r0;
        r0 = heapClassInst.heap32[r4 + numDefine3];
        heapClassInst.heap32[r5 + numDefine5] = r0;
        r0 = heapClassInst.heap32[r4 + numDefine2];
        heapClassInst.heap32[r5 + numDefine4] = r0;
        heapClassInst.heap32[r5 + numDefine7] = heapClassInst.heap32[r4 + numDefine7];
        heapClassInst.heap32[r5 + numDefine8] = heapClassInst.heap32[r4 + numDefine8];
        heapClassInst.heap32[r5 + numDefine9] = 0;
        r0 = heapClassInst.heap32[r4 + numDefine5];
        r1 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine120];
        if (!(r1 < 1)) {
            r1 = 0;
            repeat6: while (true) {
                r0 = r0 >> numDefine2;
                r0 = heapClassInst.heap32[r0 + numDefine122];
                r3 = r1 << numDefine2;
                r0 = (r0 + r3) | 0;
                r0 = r0 >> numDefine2;
                r0 = heapClassInst.heap32[r0];
                if (!(r0 != r2)) {
                    heapClassInst.heap32[r5 + numDefine9] = 1;
                }
                r1 = (r1 + 1) | 0;
                r0 = heapClassInst.heap32[r4 + numDefine5];
                r3 = r0 >> numDefine2;
                r3 = heapClassInst.heap32[r3 + numDefine120];
                if (r3 > r1) {
                    continue repeat6;
                } else {
                    break repeat6;
                }
            }
        }
        r0 = heapClassInst.heap32[r4 + numDefine6];
        r1 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r1 + numDefine120];
        repeat12: do {
            if (!(r1 < 1)) {
                r1 = 0;
                repeat14: while (true) {
                    r0 = r0 >> numDefine2;
                    r0 = heapClassInst.heap32[r0 + numDefine122];
                    r3 = r1 << numDefine2;
                    r0 = (r0 + r3) | 0;
                    r0 = r0 >> numDefine2;
                    r0 = heapClassInst.heap32[r0];
                    if (!(r0 != r2)) {
                        heapClassInst.heap32[r5 + numDefine9] = 1;
                    }
                    r1 = (r1 + 1) | 0;
                    r0 = heapClassInst.heap32[r4 + numDefine6];
                    r3 = r0 >> numDefine2;
                    r3 = heapClassInst.heap32[r3 + numDefine120];
                    if (r3 > r1) {
                        continue repeat14;
                    } else {
                        break repeat12;
                    }
                }
            }
        } while (false);
        r0 = twoEStr76;
        commonVariable.rg0 = r0;
        return;
    }

    public static void zn23btStridingMeshInterfaceD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv23btStridingMeshInterface;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn23btStridingMeshInterfaceD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv23btStridingMeshInterface;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn31btInternalTriangleIndexCallbackD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv31btInternalTriangleIndexCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn31btInternalTriangleIndexCallbackD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv31btInternalTriangleIndexCallback;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn18btTriangleCallbackD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv18btTriangleCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn18btTriangleCallbackD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv18btTriangleCallback;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn26btTriangleIndexVertexArray16unLockVertexBaseEi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        return;
    }

    public static void znk26btTriangleIndexVertexArray24unLockReadOnlyVertexBaseEi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        return;
    }

    public static void zn26btTriangleIndexVertexArray19preallocateVerticesEi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        return;
    }

    public static void zn26btTriangleIndexVertexArray18preallocateIndicesEi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        return;
    }

    public static void znk26btTriangleIndexVertexArray14hasPremadeAabbEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine12];
        r1 = 1;

        r0 = r0 == r1 ? 1 : 0;
        r0 = r0 & 1;
        commonVariable.rg0 = r0;
        return;
    }

    public static void znk26btTriangleIndexVertexArray14setPremadeAabbERK9btVector3S2(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r0 + numDefine13] = heapClassInst.heap32[r1];
        heapClassInst.heap32[r0 + numDefine14] = heapClassInst.heap32[r1 + 1];
        r2 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[r0 + numDefine15] = heapClassInst.heap32[r1 + numDefine2];
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r0 + numDefine16] = heapClassInst.heap32[r1 + numDefine3];
        heapClassInst.heap32[r0 + numDefine17] = heapClassInst.heap32[r2];
        heapClassInst.heap32[r0 + numDefine18] = heapClassInst.heap32[r2 + 1];
        heapClassInst.heap32[r0 + numDefine19] = heapClassInst.heap32[r2 + numDefine2];
        heapClassInst.heap32[r0 + numDefine20] = heapClassInst.heap32[r2 + numDefine3];
        heapClassInst.heap32[r0 + numDefine12] = 1;
        return;
    }

    public static void znk26btTriangleIndexVertexArray14getPremadeAabbEP9btVector3S1(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r1] = heapClassInst.heap32[r0 + numDefine13];
        heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0 + numDefine14];
        r2 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + numDefine15];
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine16];
        heapClassInst.heap32[r2] = heapClassInst.heap32[r0 + numDefine17];
        heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r0 + numDefine18];
        heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r0 + numDefine19];
        heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r0 + numDefine20];
        return;
    }

    public static void znk26btTriangleIndexVertexArray14getNumSubPartsEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine6];
        commonVariable.rg0 = r0;
        return;
    }

    public static void znk26btTriangleIndexVertexArray32getLockedReadOnlyVertexIndexBaseEPPKhRiR14PHYScalarTypeS3S2S3S3S5I(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + numDefine9];
        r0 = r0 >> numDefine2;
        r1 = r1 << numDefine5;
        r0 = heapClassInst.heap32[r0 + numDefine8];
        r0 = (r0 + r1) | 0;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[fp + numDefine2];
        r2 = heapClassInst.heap32[r0 + numDefine3];
        r1 = r1 >> numDefine2;
        r3 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[r1] = r2;
        r1 = r3 >> numDefine2;
        r2 = heapClassInst.heap32[r0 + numDefine4];
        r3 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heap32[r1] = r2;
        r1 = r3 >> numDefine2;
        r2 = heapClassInst.heap32[r0 + numDefine7];
        r3 = heapClassInst.heap32[fp + numDefine4];
        heapClassInst.heap32[r1] = r2;
        r1 = r3 >> numDefine2;
        r2 = heapClassInst.heap32[r0 + numDefine5];
        r3 = heapClassInst.heap32[fp + numDefine7];
        heapClassInst.heap32[r1] = r2;
        r1 = r3 >> numDefine2;
        r2 = heapClassInst.heap32[r0];
        r3 = heapClassInst.heap32[fp + numDefine5];
        heapClassInst.heap32[r1] = r2;
        r1 = r3 >> numDefine2;
        r2 = heapClassInst.heap32[r0 + 1];
        r3 = heapClassInst.heap32[fp + numDefine6];
        heapClassInst.heap32[r1] = r2;
        r1 = r3 >> numDefine2;
        r2 = heapClassInst.heap32[r0 + numDefine2];
        r3 = heapClassInst.heap32[fp + numDefine8];
        heapClassInst.heap32[r1] = r2;
        r1 = r3 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine6];
        heapClassInst.heap32[r1] = r0;
        return;
    }

    public static void zn26btTriangleIndexVertexArray24getLockedVertexIndexBaseEPPhRiR14PHYScalarTypeS2S1S2S2S4I(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine7];
        r3 = heapClassInst.heap32[fp + numDefine9];
        heapClassInst.heap32[g0] = r0;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r0 = commonVariable.rg0;
        if (r0 > r3) {
            r0 = heapClassInst.heap32[fp + 1];
            r2 = heapClassInst.heap32[fp + numDefine2];
            r4 = heapClassInst.heap32[fp + numDefine3];
            r5 = heapClassInst.heap32[fp + numDefine4];
            r6 = heapClassInst.heap32[fp + numDefine5];
            r7 = heapClassInst.heap32[fp + numDefine6];
            r8 = heapClassInst.heap32[fp + numDefine7];
            r9 = heapClassInst.heap32[fp + numDefine8];
            r3 = r3 << numDefine5;
            r1 = heapClassInst.heap32[r1 + numDefine8];
            r1 = (r1 + r3) | 0;
            r1 = r1 >> numDefine2;
            r3 = heapClassInst.heap32[r1 + numDefine3];
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[r2] = r3;
            r0 = r0 >> numDefine2;
            r2 = heapClassInst.heap32[r1 + numDefine4];
            heapClassInst.heap32[r0] = r2;
            r0 = r4 >> numDefine2;
            r2 = heapClassInst.heap32[r1 + numDefine7];
            heapClassInst.heap32[r0] = r2;
            r0 = r5 >> numDefine2;
            r2 = heapClassInst.heap32[r1 + numDefine5];
            heapClassInst.heap32[r0] = r2;
            r0 = r8 >> numDefine2;
            r2 = heapClassInst.heap32[r1];
            heapClassInst.heap32[r0] = r2;
            r0 = r6 >> numDefine2;
            r2 = heapClassInst.heap32[r1 + 1];
            heapClassInst.heap32[r0] = r2;
            r0 = r7 >> numDefine2;
            r2 = heapClassInst.heap32[r1 + numDefine2];
            heapClassInst.heap32[r0] = r2;
            r0 = r9 >> numDefine2;
            r1 = heapClassInst.heap32[r1 + numDefine6];
            heapClassInst.heap32[r0] = r1;
            return;
        } else {
            r1 = twoEStr367;
            r3 = twoEStr1368;
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = r3;
            heapClassInst.heap32[g0 + numDefine2] = numDefine41;
            assertNew(i7);
        }
    }

    public static void zn26btTriangleIndexVertexArrayD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv26btTriangleIndexVertexArray;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heap32[r2 + numDefine8];
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine36];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine8] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine36] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine8] = 0;
        r1 = ztv23btStridingMeshInterface;
        heapClassInst.heap32[r2 + numDefine6] = 0;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2 + numDefine7] = 0;
        heapClassInst.heap32[r2] = r1;
        if (!(r0 == 0)) {
            r0 = gNumAlignedFree;
            r0 = r0 >> numDefine2;
            r1 = heapClassInst.heap32[r0];
            r1 = (r1 + 1) | 0;
            heapClassInst.heap32[r0] = r1;
            r0 = heapClassInst.heap32[r2 + -1];
            heapClassInst.heap32[g0] = r0;
            free(i7);
        }
        return;
    }

    public static void zn26btTriangleIndexVertexArrayD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv26btTriangleIndexVertexArray;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        r1 = heapClassInst.heap32[r2 + numDefine8];
        if (!(r1 == 0)) {
            r3 = heapClassInst.heapU8[r0 + numDefine36];
            if (!(r3 == 0)) {
                r3 = gNumAlignedFree;
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3];
                r4 = (r4 + 1) | 0;
                r1 = r1 >> numDefine2;
                heapClassInst.heap32[r3] = r4;
                r1 = heapClassInst.heap32[r1 + -1];
                heapClassInst.heap32[g0] = r1;
                free(i7);
            }
            heapClassInst.heap32[r2 + numDefine8] = 0;
        }
        r1 = 1;
        heapClassInst.heap8[r0 + numDefine36] = (byte) r1;
        heapClassInst.heap32[r2 + numDefine8] = 0;
        r0 = ztv23btStridingMeshInterface;
        heapClassInst.heap32[r2 + numDefine6] = 0;
        r0 = (r0 + numDefine8) | 0;
        heapClassInst.heap32[r2 + numDefine7] = 0;
        heapClassInst.heap32[r2] = r0;
        return;
    }

    public static void znk19btTriangleMeshShape7getNameEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr372;
        commonVariable.rg0 = r0;
        return;
    }

    public static void znk19btTriangleMeshShape7getAabbERK11btTransformR9btVector3S4(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine11];
        f0 = heapClassInst.heapFloat[r1 + numDefine10];
        f1 = heapClassInst.heapFloat[r1 + numDefine6];
        f2 = heapClassInst.heapFloat[r1 + numDefine9];
        f3 = heapClassInst.heapFloat[r1 + numDefine5];
        f4 = heapClassInst.heapFloat[r1 + numDefine8];
        f5 = heapClassInst.heapFloat[r1 + numDefine4];
        heapClassInst.heap32[g0] = r0;
        functionTable.get(r2 >> numDefine2).accept(i7);
        f6 = (float) commonVariable.fg0;
        r2 = heapClassInst.heap32[r1];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine11];
        heapClassInst.heap32[g0] = r0;
        functionTable.get(r2 >> numDefine2).accept(i7);
        f7 = (float) commonVariable.fg0;
        r2 = heapClassInst.heap32[r1];
        r2 = r2 >> numDefine2;
        r2 = heapClassInst.heap32[r2 + numDefine11];
        heapClassInst.heap32[g0] = r0;
        functionTable.get(r2 >> numDefine2).accept(i7);
        r0 = heapClassInst.heap32[fp + 1];
        f4 = f4 - f5;
        f5 = (float) numDefineFloat05;
        f2 = f2 - f3;
        f0 = f0 - f1;
        f1 = heapClassInst.heapFloat[r1 + numDefine10];
        f3 = heapClassInst.heapFloat[r1 + numDefine6];
        f9 = heapClassInst.heapFloat[r1 + numDefine9];
        f10 = heapClassInst.heapFloat[r1 + numDefine5];
        f11 = heapClassInst.heapFloat[r1 + numDefine8];
        f12 = heapClassInst.heapFloat[r1 + numDefine4];
        r0 = r0 >> numDefine2;
        f4 = f4 * f5;
        f2 = f2 * f5;
        f0 = f0 * f5;
        f1 = f1 + f3;
        f3 = f9 + f10;
        f9 = f11 + f12;
        f10 = heapClassInst.heapFloat[r0 + numDefine10];
        r1 = heapClassInst.heap32[fp + numDefine2];
        r2 = heapClassInst.heap32[fp + numDefine3];
        f4 = (float) (f4 + commonVariable.fg0);
        f2 = f2 + f7;
        f0 = f0 + f6;
        f1 = f1 * f5;
        f3 = f3 * f5;
        f5 = f9 * f5;
        f6 = 0;
        if (f10 < f6) {
            f7 = -f10;
        } else {
            f7 = f10;
        }
        f8 = heapClassInst.heapFloat[r0 + numDefine9];
        if (f8 < f6) {
            f9 = -f8;
        } else {
            f9 = f8;
        }
        f11 = heapClassInst.heapFloat[r0 + numDefine8];
        if (f11 < f6) {
            f12 = -f11;
        } else {
            f12 = f11;
        }
        f13 = heapClassInst.heapFloat[r0 + numDefine6];
        if (f13 < f6) {
            f14 = -f13;
        } else {
            f14 = f13;
        }
        f15 = heapClassInst.heapFloat[r0 + numDefine5];
        if (f15 < f6) {
            f16 = -f15;
        } else {
            f16 = f15;
        }
        f17 = heapClassInst.heapFloat[r0 + numDefine4];
        if (f17 < f6) {
            f18 = -f17;
        } else {
            f18 = f17;
        }
        f19 = heapClassInst.heapFloat[r0 + numDefine2];
        if (f19 < f6) {
            f20 = -f19;
        } else {
            f20 = f19;
        }
        f21 = heapClassInst.heapFloat[r0 + 1];
        if (f21 < f6) {
            f22 = -f21;
        } else {
            f22 = f21;
        }
        f23 = heapClassInst.heapFloat[r0];
        if (f23 < f6) {
            f6 = -f23;
        } else {
            f6 = f23;
        }
        f23 = f23 * f5;
        f21 = f21 * f3;
        f17 = f17 * f5;
        f15 = f15 * f3;
        f21 = f23 + f21;
        f19 = f19 * f1;
        f6 = f6 * f4;
        f22 = f22 * f2;
        f5 = f11 * f5;
        f3 = f8 * f3;
        f8 = f17 + f15;
        f11 = f13 * f1;
        f13 = f18 * f4;
        f15 = f16 * f2;
        f16 = f21 + f19;
        f17 = heapClassInst.heapFloat[r0 + numDefine12];
        f6 = f6 + f22;
        f18 = f20 * f0;
        f3 = f5 + f3;
        f1 = f10 * f1;
        f4 = f12 * f4;
        f2 = f9 * f2;
        f5 = f8 + f11;
        f8 = heapClassInst.heapFloat[r0 + numDefine13];
        f9 = heapClassInst.heapFloat[r0 + numDefine14];
        f10 = f13 + f15;
        f11 = f14 * f0;
        f12 = f16 + f17;
        f6 = f6 + f18;
        f1 = f3 + f1;
        r0 = r1 >> numDefine2;
        f2 = f4 + f2;
        f0 = f7 * f0;
        f3 = f5 + f8;
        f4 = f10 + f11;
        f5 = f12 - f6;
        f1 = f1 + f9;
        f0 = f2 + f0;
        f2 = f3 - f4;
        heapClassInst.heapFloat[r0] = (float) f5;
        f5 = f1 - f0;
        heapClassInst.heapFloat[r0 + 1] = (float) f2;
        heapClassInst.heapFloat[r0 + numDefine2] = (float) f5;
        r1 = r2 >> numDefine2;
        f2 = f12 + f6;
        heapClassInst.heap32[r0 + numDefine3] = 0;
        f3 = f3 + f4;
        heapClassInst.heapFloat[r1] = (float) f2;
        f0 = f1 + f0;
        heapClassInst.heapFloat[r1 + 1] = (float) f3;
        heapClassInst.heapFloat[r1 + numDefine2] = (float) f0;
        heapClassInst.heap32[r1 + numDefine3] = 0;
        return;
    }

    public static void zn19btTriangleMeshShape15recalcLocalAabbEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg64;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = 0;
        repeat1: while (true) {
            r2 = sp + numDefineNeg16;
            r3 = r2 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg4] = 0;
            heapClassInst.heap32[r3 + 1] = 0;
            heapClassInst.heap32[r3 + numDefine2] = 0;
            r4 = (r2 + r1) | 0;
            heapClassInst.heap32[r3 + numDefine3] = 0;
            r3 = r4 >> numDefine2;
            heapClassInst.heap32[r3] = numDefine53216;
            r4 = r0 >> numDefine2;
            r5 = heapClassInst.heap32[r4];
            r5 = r5 >> numDefine2;
            r5 = heapClassInst.heap32[r5 + numDefine16];
            r6 = sp + numDefineNeg32;
            heapClassInst.heap32[g0] = r6;
            heapClassInst.heap32[g0 + 1] = r0;
            heapClassInst.heap32[g0 + numDefine2] = r2;
            r7 = (r6 + r1) | 0;
            functionTable.get(r5 >> numDefine2).accept(i7);
            r5 = r7 >> numDefine2;
            r7 = (r0 + r1) | 0;
            f0 = heapClassInst.heapFloat[r5];
            f1 = heapClassInst.heapFloat[r4 + numDefine3];
            f0 = f0 + f1;
            r7 = r7 >> numDefine2;
            heapClassInst.heapFloat[r7 + numDefine8] = (float) f0;
            heapClassInst.heap32[r3] = numDefineNeg30432;
            r3 = heapClassInst.heap32[r4];
            r3 = r3 >> numDefine2;
            r3 = heapClassInst.heap32[r3 + numDefine16];
            r8 = sp + numDefineNeg48;
            heapClassInst.heap32[g0] = r8;
            heapClassInst.heap32[g0 + 1] = r0;
            heapClassInst.heap32[g0 + numDefine2] = r2;
            functionTable.get(r3 >> numDefine2).accept(i7);
            r2 = r6 >> numDefine2;
            r3 = r8 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg8] = heapClassInst.heap32[fp + numDefineNeg12];
            heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r3 + 1];
            heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r3 + numDefine2];
            heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r3 + numDefine3];
            f0 = heapClassInst.heapFloat[r5];
            f1 = heapClassInst.heapFloat[r4 + numDefine3];
            r1 = (r1 + numDefine4) | 0;
            f0 = f0 - f1;
            heapClassInst.heapFloat[r7 + numDefine4] = (float) f0;
            if (r1 != numDefine12) {
                continue repeat1;
            } else {
                break repeat1;
            }
        }
        return;
    }

    public static void zn21SupportVertexCallbackD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv18btTriangleCallback;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn21SupportVertexCallbackD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv18btTriangleCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn21SupportVertexCallback15processTriangleEP9btVector3ii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp];
        r1 = r1 >> numDefine2;
        r0 = r0 >> numDefine2;
        f0 = heapClassInst.heapFloat[r1 + numDefine22];
        f1 = heapClassInst.heapFloat[r0];
        f2 = heapClassInst.heapFloat[r1 + numDefine23];
        f3 = heapClassInst.heapFloat[r0 + 1];
        f4 = heapClassInst.heapFloat[r1 + numDefine24];
        f5 = heapClassInst.heapFloat[r0 + numDefine2];
        f1 = f0 * f1;
        f3 = f2 * f3;
        f1 = f1 + f3;
        f3 = f4 * f5;
        f5 = heapClassInst.heapFloat[r1 + numDefine21];
        f1 = f1 + f3;
        if (f5 < f1) {
            heapClassInst.heapFloat[r1 + numDefine21] = (float) f1;
            heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0];
            heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + 1];
            heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];
            heapClassInst.heap32[r1 + numDefine4] = heapClassInst.heap32[r0 + numDefine3];
            f5 = f1;
        }
        f1 = heapClassInst.heapFloat[r0 + numDefine4];
        f3 = heapClassInst.heapFloat[r0 + numDefine5];
        f1 = f0 * f1;
        f3 = f2 * f3;
        f6 = heapClassInst.heapFloat[r0 + numDefine6];
        f1 = f1 + f3;
        f3 = f4 * f6;
        f1 = f1 + f3;
        if (f5 < f1) {
            heapClassInst.heapFloat[r1 + numDefine21] = (float) f1;
            heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0 + numDefine4];
            heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + numDefine5];
            heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine6];
            heapClassInst.heap32[r1 + numDefine4] = heapClassInst.heap32[r0 + numDefine7];
            f5 = f1;
        }
        f1 = heapClassInst.heapFloat[r0 + numDefine8];
        f3 = heapClassInst.heapFloat[r0 + numDefine9];
        f0 = f0 * f1;
        f1 = f2 * f3;
        f2 = heapClassInst.heapFloat[r0 + numDefine10];
        f0 = f0 + f1;
        f1 = f4 * f2;
        f0 = f0 + f1;
        if (f5 < f0) {
            heapClassInst.heapFloat[r1 + numDefine21] = (float) f0;
            heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0 + numDefine8];
            heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + numDefine9];
            heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine10];
            heapClassInst.heap32[r1 + numDefine4] = heapClassInst.heap32[r0 + numDefine11];
            return;
        } else {
            return;
        }
    }

    public static void zn19btTriangleMeshShape15setLocalScalingERK9btVector3(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[r1 + numDefine12];
        r1 = r1 >> numDefine2;
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r2];
        heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r2 + 1];
        heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r2 + numDefine3];
        heapClassInst.heap32[r1 + numDefine4] = heapClassInst.heap32[r2 + numDefine3];
        heapClassInst.heap32[g0] = r0;
        zn19btTriangleMeshShape15recalcLocalAabbEv(i7);
        return;
    }

    public static void znk19btTriangleMeshShape15getLocalScalingEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine12];
        r0 = (r0 + numDefine4) | 0;
        commonVariable.rg0 = r0;
        return;
    }

    public static void zznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4EN16FilteredCallbackD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv31btInternalTriangleIndexCallback;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4EN16FilteredCallbackD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv31btInternalTriangleIndexCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4EN16FilteredCallback28internalProcessTriangleIndexEPS2Ii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[fp];
        f0 = heapClassInst.heapFloat[r1];
        f1 = heapClassInst.heapFloat[r1 + numDefine4];
        f2 = heapClassInst.heapFloat[r1 + numDefine8];
        f3 = f0 < f1 ? f0 : f1;
        r2 = r2 >> numDefine2;
        f3 = f3 < f2 ? f3 : f2;
        f4 = heapClassInst.heapFloat[r2 + numDefine6];
        if (!(f3 > f4)) {
            f0 = f0 > f1 ? f0 : f1;
            f0 = f0 > f2 ? f0 : f2;
            f1 = heapClassInst.heapFloat[r2 + numDefine2];
            if (!(f0 < f1)) {
                f0 = heapClassInst.heapFloat[r1 + numDefine2];
                f1 = heapClassInst.heapFloat[r1 + numDefine6];
                f2 = heapClassInst.heapFloat[r1 + numDefine10];
                f3 = f0 < f1 ? f0 : f1;
                f3 = f3 < f2 ? f3 : f2;
                f4 = heapClassInst.heapFloat[r2 + numDefine8];
                if (!(f3 > f4)) {
                    f0 = f0 > f1 ? f0 : f1;
                    f0 = f0 > f2 ? f0 : f2;
                    f1 = heapClassInst.heapFloat[r2 + numDefine4];
                    if (!(f0 < f1)) {
                        f0 = heapClassInst.heapFloat[r1 + 1];
                        f1 = heapClassInst.heapFloat[r1 + numDefine5];
                        f2 = heapClassInst.heapFloat[r1 + numDefine9];
                        f3 = f0 < f1 ? f0 : f1;
                        f3 = f3 < f2 ? f3 : f2;
                        f4 = heapClassInst.heapFloat[r2 + numDefine7];
                        if (!(f3 > f4)) {
                            f0 = f0 > f1 ? f0 : f1;
                            f0 = f0 > f2 ? f0 : f2;
                            f1 = heapClassInst.heapFloat[r2 + numDefine3];
                            if (!(f0 < f1)) {
                                r1 = heapClassInst.heap32[fp + numDefine2];
                                r3 = heapClassInst.heap32[fp + numDefine3];
                                r2 = heapClassInst.heap32[r2 + 1];
                                r4 = r2 >> numDefine2;
                                r4 = heapClassInst.heap32[r4];
                                r4 = r4 >> numDefine2;
                                r4 = heapClassInst.heap32[r4 + numDefine2];
                                heapClassInst.heap32[g0] = r2;
                                heapClassInst.heap32[g0 + 1] = r0;
                                heapClassInst.heap32[g0 + numDefine2] = r1;
                                heapClassInst.heap32[g0 + numDefine3] = r3;
                                functionTable.get(r4 >> numDefine2).accept(i7);
                            }
                        }
                    }
                }
            }
        }
        return;
    }

    public static void znk19btTriangleMeshShape21calculateLocalInertiaEfR9btVector3(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = twoEStr10;
        r1 = twoEStr3375;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = numDefine188;
        assertNew(i7);
    }

    public static void znk19btTriangleMeshShape24localGetSupportingVertexERK9btVector3(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg152;
        int g0 = i7 >> numDefine2;
        r0 = ztv21SupportVertexCallback;
        r1 = sp + numDefineNeg120;
        r0 = (r0 + numDefine8) | 0;
        r2 = r1 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg30] = r0;
        heapClassInst.heap32[r2 + 1] = 0;
        heapClassInst.heap32[r2 + numDefine2] = 0;
        heapClassInst.heap32[r2 + numDefine3] = 0;
        heapClassInst.heap32[r2 + numDefine4] = 0;
        heapClassInst.heap32[r2 + numDefine5] = numDefine53216;
        heapClassInst.heap32[r2 + numDefine6] = 0;
        heapClassInst.heap32[r2 + numDefine7] = 0;
        heapClassInst.heap32[r2 + numDefine8] = 0;
        heapClassInst.heap32[r2 + numDefine9] = 0;
        heapClassInst.heap32[r2 + numDefine10] = numDefine53216;
        heapClassInst.heap32[r2 + numDefine11] = 0;
        heapClassInst.heap32[r2 + numDefine12] = 0;
        heapClassInst.heap32[r2 + numDefine13] = 0;
        heapClassInst.heap32[r2 + numDefine14] = 0;
        heapClassInst.heap32[r2 + numDefine15] = numDefine53216;
        heapClassInst.heap32[r2 + numDefine16] = 0;
        heapClassInst.heap32[r2 + numDefine17] = 0;
        heapClassInst.heap32[r2 + numDefine18] = 0;
        heapClassInst.heap32[r2 + numDefine19] = 0;
        r0 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[r2 + numDefine20] = 0;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r2 + numDefine21] = (int) numDefineNeg39253;
        f0 = 0;
        f1 = heapClassInst.heapFloat[r0 + 1];
        f2 = heapClassInst.heapFloat[r0];
        f3 = heapClassInst.heapFloat[r0 + numDefine2];
        f4 = f1 * f0;
        f5 = f2 * f0;
        f2 = f2 + f4;
        f0 = f3 * f0;
        f1 = f5 + f1;
        f2 = f2 + f0;
        f4 = f5 + f4;
        f0 = f1 + f0;
        heapClassInst.heapFloat[r2 + numDefine22] = (float) f2;
        f1 = f4 + f3;
        heapClassInst.heapFloat[r2 + numDefine23] = (float) f0;
        heapClassInst.heapFloat[r2 + numDefine24] = (float) f1;
        r0 = sp + numDefineNeg136;
        heapClassInst.heap32[r2 + numDefine25] = 0;
        r3 = r0 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg34] = numDefine44395;
        heapClassInst.heap32[r3 + 1] = numDefine44395;
        r4 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[r3 + numDefine2] = numDefine44395;
        r5 = r4 >> numDefine2;
        heapClassInst.heap32[r3 + numDefine3] = 0;
        r3 = heapClassInst.heap32[r5];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine15];
        r5 = sp + numDefineNeg16;
        r6 = r5 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg4] = (int) numDefineNeg39253;
        heapClassInst.heap32[r6 + 1] = (int) numDefineNeg39253;
        heapClassInst.heap32[r6 + numDefine2] = (int) numDefineNeg39253;
        heapClassInst.heap32[r6 + numDefine3] = 0;
        heapClassInst.heap32[g0] = r4;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = r5;
        heapClassInst.heap32[g0 + numDefine3] = r0;
        functionTable.get(r3 >> numDefine2).accept(i7);
        r0 = heapClassInst.heap32[fp];
        f0 = heapClassInst.heapFloat[r2 + numDefine4];
        f1 = heapClassInst.heapFloat[r2 + numDefine3];
        f2 = heapClassInst.heapFloat[r2 + numDefine2];
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r0] = heapClassInst.heap32[r2 + 1];
        heapClassInst.heapFloat[r0 + 1] = (float) f2;
        heapClassInst.heapFloat[r0 + numDefine2] = (float) f1;
        heapClassInst.heapFloat[r0 + numDefine3] = (float) f0;
        return;
    }

    public static void znk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg56;
        int g0 = i7 >> numDefine2;
        r0 = ztvznk19btTriangleMeshShape19processAllTrianglesEP18btTriangleCallbackRK9btVector3S4E16FilteredCallback;
        r1 = sp + numDefineNeg40;
        r0 = (r0 + numDefine8) | 0;
        r2 = heapClassInst.heap32[fp + numDefine2];
        r3 = r1 >> numDefine2;
        r4 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[fp + numDefineNeg10] = r0;
        r0 = r2 >> numDefine2;
        heapClassInst.heap32[r3 + 1] = r4;
        heapClassInst.heap32[r3 + numDefine2] = heapClassInst.heap32[r0];
        heapClassInst.heap32[r3 + numDefine3] = heapClassInst.heap32[r0 + 1];
        r4 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heap32[r3 + numDefine4] = heapClassInst.heap32[r0 + numDefine2];
        r5 = r4 >> numDefine2;
        heapClassInst.heap32[r3 + numDefine5] = heapClassInst.heap32[r0 + numDefine3];
        heapClassInst.heap32[r3 + numDefine6] = heapClassInst.heap32[r5];
        heapClassInst.heap32[r3 + numDefine7] = heapClassInst.heap32[r5 + 1];
        r0 = heapClassInst.heap32[fp];
        heapClassInst.heap32[r3 + numDefine8] = heapClassInst.heap32[r5 + numDefine2];
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r3 + numDefine9] = heapClassInst.heap32[r5 + numDefine3];
        r0 = heapClassInst.heap32[r0 + numDefine12];
        r3 = r0 >> numDefine2;
        r3 = heapClassInst.heap32[r3];
        r3 = r3 >> numDefine2;
        r3 = heapClassInst.heap32[r3 + numDefine2];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = r2;
        heapClassInst.heap32[g0 + numDefine3] = r4;
        functionTable.get(r3 >> numDefine2).accept(i7);
        return;
    }

    public static void zn19btTriangleMeshShapeD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv14btConcaveShape;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn19btTriangleMeshShapeD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv14btConcaveShape;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void globalDzn19btGenericMemoryPool24allocateFromFreeNodesEj(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        return;
    }

    public static void zn16btPointCollectorD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv16btPointCollector;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn16btPointCollectorD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv16btPointCollector;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn16btPointCollector20setShapeIdentifiersAEii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        return;
    }

    public static void zn16btPointCollector20setShapeIdentifiersBEii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        return;
    }

    public static void zn16btPointCollector15addContactPointERK9btVector3S2F(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        f0 = heapClassInst.heapFloat[fp + numDefine3];
        r1 = r0 >> numDefine2;
        f1 = heapClassInst.heapFloat[r1 + numDefine9];
        if (!(f1 <= f0)) {
            r2 = heapClassInst.heap32[fp + 1];
            r3 = heapClassInst.heap32[fp + numDefine2];
            r4 = 1;
            r2 = r2 >> numDefine2;
            heapClassInst.heap8[r0 + numDefine40] = (byte) r4;
            heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r2];
            heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r2 + 1];
            heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r2 + numDefine3];
            r0 = r3 >> numDefine2;
            heapClassInst.heap32[r1 + numDefine4] = heapClassInst.heap32[r2 + numDefine3];
            heapClassInst.heap32[r1 + numDefine5] = heapClassInst.heap32[r0];
            heapClassInst.heap32[r1 + numDefine6] = heapClassInst.heap32[r0 + 1];
            heapClassInst.heap32[r1 + numDefine7] = heapClassInst.heap32[r0 + numDefine2];
            heapClassInst.heap32[r1 + numDefine8] = heapClassInst.heap32[r0 + numDefine3];
            heapClassInst.heapFloat[r1 + numDefine9] = (float) f0;
        }
        return;
    }

    public static void zn27btContinuousConvexCollisionD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv12btConvexCast;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn27btContinuousConvexCollisionD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv12btConvexCast;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn27btContinuousConvexCollisionTransformConvexCast10CastResultE(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        int r20 = 0;
        int r21 = 0;
        int r22 = 0;
        int r23 = 0;
        int r24 = 0;
        int r25 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg816;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + 1];
        r2 = 0;
        r3 = r1 >> numDefine2;
        heapClassInst.heap8[r1 + numDefine312] = (byte) r2;
        r4 = 1;
        heapClassInst.heap32[r3] = 0;
        heapClassInst.heap8[r1 + numDefine356] = (byte) r4;
        heapClassInst.heap32[r3 + numDefine73] = numDefine44395;
        heapClassInst.heap32[r3 + numDefine74] = numDefine44395;
        heapClassInst.heap32[r3 + numDefine75] = numDefine44395;
        heapClassInst.heap32[r3 + numDefine76] = 0;
        heapClassInst.heap8[r1 + numDefine352] = (byte) r2;
        heapClassInst.heap32[r3 + numDefine84] = 0;
        heapClassInst.heap32[r3 + numDefine85] = 0;
        heapClassInst.heap32[r3 + numDefine86] = 0;
        heapClassInst.heap32[r3 + numDefine87] = 0;
        r3 = heapClassInst.heapU8[r1 + numDefine332];
        r5 = heapClassInst.heap32[fp + 1];
        r6 = heapClassInst.heap32[fp + numDefine2];
        r3 = r3 & numDefine240;
        r7 = r6 >> numDefine2;
        heapClassInst.heap8[r1 + numDefine332] = (byte) r3;
        r1 = r5 >> numDefine2;
        f0 = heapClassInst.heapFloat[r7 + numDefine14];
        f1 = heapClassInst.heapFloat[r1 + numDefine14];
        f2 = heapClassInst.heapFloat[r7 + numDefine13];
        f3 = heapClassInst.heapFloat[r1 + numDefine13];
        f4 = heapClassInst.heapFloat[r7 + numDefine12];
        f5 = heapClassInst.heapFloat[r1 + numDefine12];
        r3 = sp + numDefineNeg40;
        r7 = sp + numDefineNeg44;
        heapClassInst.heap32[g0] = r5;
        heapClassInst.heap32[g0 + 1] = r6;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        heapClassInst.heap32[g0 + numDefine3] = r7;
        zn15btTransformUtil22calculateDiffAxisAngleERK11btTransformS2R9btVector3Rf(i7);
        r3 = r3 >> numDefine2;
        f6 = heapClassInst.heapFloat[r3 + numDefine2];
        f7 = heapClassInst.heapFloat[fp + numDefineNeg11];
        f8 = heapClassInst.heapFloat[r3 + 1];
        f9 = heapClassInst.heapFloat[fp + numDefineNeg10];
        r3 = sp + numDefineNeg96;
        f9 = f9 * f7;
        f8 = f8 * f7;
        r6 = r3 >> numDefine2;
        heapClassInst.heapFloat[fp + numDefineNeg24] = (float) f9;
        f6 = f6 * f7;
        heapClassInst.heapFloat[r6 + 1] = (float) f8;
        r7 = heapClassInst.heap32[fp + numDefine3];
        r8 = heapClassInst.heap32[fp + numDefine4];
        heapClassInst.heapFloat[r6 + numDefine2] = (float) f6;
        r9 = r8 >> numDefine2;
        heapClassInst.heap32[r6 + numDefine3] = 0;
        r6 = r7 >> numDefine2;
        f7 = heapClassInst.heapFloat[r9 + numDefine14];
        f10 = heapClassInst.heapFloat[r6 + numDefine14];
        f11 = heapClassInst.heapFloat[r9 + numDefine13];
        f12 = heapClassInst.heapFloat[r6 + numDefine13];
        f13 = heapClassInst.heapFloat[r9 + numDefine12];
        f14 = heapClassInst.heapFloat[r6 + numDefine12];
        r9 = sp + numDefineNeg16;
        r10 = sp + numDefineNeg20;
        heapClassInst.heap32[g0] = r7;
        heapClassInst.heap32[g0 + 1] = r8;
        heapClassInst.heap32[g0 + numDefine2] = r9;
        heapClassInst.heap32[g0 + numDefine3] = r10;
        zn15btTransformUtil22calculateDiffAxisAngleERK11btTransformS2R9btVector3Rf(i7);
        r8 = r9 >> numDefine2;
        f15 = heapClassInst.heapFloat[r8 + numDefine2];
        f16 = heapClassInst.heapFloat[fp + numDefineNeg5];
        f17 = heapClassInst.heapFloat[r8 + 1];
        f18 = heapClassInst.heapFloat[fp + numDefineNeg4];
        r8 = sp + numDefineNeg112;
        f18 = f18 * f16;
        f17 = f17 * f16;
        r9 = r8 >> numDefine2;
        heapClassInst.heapFloat[fp + numDefineNeg28] = (float) f18;
        f15 = f15 * f16;
        heapClassInst.heapFloat[r9 + 1] = (float) f17;
        heapClassInst.heapFloat[r9 + numDefine2] = (float) f15;
        heapClassInst.heap32[r9 + numDefine3] = 0;
        r9 = heapClassInst.heap32[r0 + numDefine3];
        r10 = r9 >> numDefine2;
        r10 = heapClassInst.heap32[r10];
        r10 = r10 >> numDefine2;
        r10 = heapClassInst.heap32[r10 + numDefine4];
        heapClassInst.heap32[g0] = r9;
        functionTable.get(r10 >> numDefine2).accept(i7);
        f16 = (float) commonVariable.fg0;
        r9 = heapClassInst.heap32[r0 + numDefine4];
        r10 = r9 >> numDefine2;
        r10 = heapClassInst.heap32[r10];
        r10 = r10 >> numDefine2;
        r10 = heapClassInst.heap32[r10 + numDefine4];
        heapClassInst.heap32[g0] = r9;
        f9 = f9 * f9;
        f8 = f8 * f8;
        functionTable.get(r10 >> numDefine2).accept(i7);
        f19 = (float) commonVariable.fg0;
        f8 = f9 + f8;
        f6 = f6 * f6;
        f6 = f8 + f6;
        heapClassInst.heapFloat[g0] = (float) f6;
        f6 = f18 * f18;
        f8 = f17 * f17;
        sqrtf(i7);
        f9 = (float) commonVariable.fg0;
        f11 = f11 - f12;
        f2 = f2 - f3;
        f3 = f13 - f14;
        f4 = f4 - f5;
        f5 = f6 + f8;
        f6 = f15 * f15;
        f8 = f11 - f2;
        f12 = f3 - f4;
        f7 = f7 - f10;
        f0 = f0 - f1;
        f1 = f5 + f6;
        f5 = f7 - f0;
        heapClassInst.heapFloat[g0] = (float) f1;
        f1 = f12 * f12;
        f6 = f8 * f8;
        sqrtf(i7);
        f1 = f1 + f6;
        f6 = f5 * f5;
        f1 = f1 + f6;
        f6 = f9 * f16;
        f9 = (float) (commonVariable.fg0 * f19);
        heapClassInst.heapFloat[g0] = (float) f1;
        f1 = f6 + f9;
        sqrtf(i7);
        f6 = (float) (commonVariable.fg0 + f1);
        f9 = 0;
        repeat1: do {
            if (!(f6 == f9)) {
                r9 = ztv16btPointCollector;
                r9 = (r9 + numDefine8) | 0;
                r10 = sp + numDefineNeg176;
                heapClassInst.heap32[fp + numDefineNeg44] = r9;
                r11 = r10 >> numDefine2;
                heapClassInst.heap32[r11 + numDefine9] = numDefine44395;
                heapClassInst.heap8[sp + numDefineNeg136] = (byte) r2;
                r12 = heapClassInst.heap32[r0 + numDefine4];
                r13 = r12 >> numDefine2;
                r13 = heapClassInst.heap32[r13];
                r13 = r13 >> numDefine2;
                r13 = heapClassInst.heap32[r13 + numDefine11];
                r14 = heapClassInst.heap32[r0 + numDefine2];
                r15 = heapClassInst.heap32[r0 + 1];
                heapClassInst.heap32[g0] = r12;
                functionTable.get(r13 >> numDefine2).accept(i7);
                f6 = (float) commonVariable.fg0;
                r12 = heapClassInst.heap32[r0 + numDefine3];
                r13 = r12 >> numDefine2;
                r13 = heapClassInst.heap32[r13];
                r13 = r13 >> numDefine2;
                r13 = heapClassInst.heap32[r13 + numDefine11];
                heapClassInst.heap32[g0] = r12;
                functionTable.get(r13 >> numDefine2).accept(i7);
                r12 = heapClassInst.heap32[r0 + numDefine4];
                r13 = heapClassInst.heap32[r0 + numDefine3];
                r16 = r12 >> numDefine2;
                r17 = r13 >> numDefine2;
                r18 = ztv17btGjkPairDetector;
                r16 = heapClassInst.heap32[r16 + 1];
                r17 = heapClassInst.heap32[r17 + 1];
                r19 = sp + numDefineNeg256;
                r18 = (r18 + numDefine8) | 0;
                r20 = r19 >> numDefine2;
                heapClassInst.heap32[fp + numDefineNeg64] = r18;
                heapClassInst.heap32[r20 + 1] = 0;
                heapClassInst.heap32[r20 + numDefine2] = numDefine53216;
                heapClassInst.heap32[r20 + numDefine3] = 0;
                heapClassInst.heap32[r20 + numDefine4] = 0;
                heapClassInst.heap32[r20 + numDefine5] = r14;
                heapClassInst.heap32[r20 + numDefine6] = r15;
                heapClassInst.heap32[r20 + numDefine7] = r13;
                heapClassInst.heap32[r20 + numDefine8] = r12;
                heapClassInst.heap32[r20 + numDefine9] = r17;
                heapClassInst.heap32[r20 + numDefine10] = r16;
                heapClassInst.heapFloat[r20 + numDefine11] = (float) commonVariable.fg0;
                heapClassInst.heapFloat[r20 + numDefine12] = (float) f6;
                heapClassInst.heap8[sp + numDefineNeg204] = (byte) r2;
                r12 = sp + numDefineNeg392;
                heapClassInst.heap32[r20 + numDefine15] = -1;
                r13 = r12 >> numDefine2;
                heapClassInst.heap32[r20 + numDefine18] = 1;
                heapClassInst.heap32[r13 + numDefine32] = numDefine44395;
                heapClassInst.heap32[r13 + numDefine33] = 0;
                heapClassInst.heap32[fp + numDefineNeg98] = heapClassInst.heap32[r1];
                heapClassInst.heap32[r13 + 1] = heapClassInst.heap32[r1 + 1];
                heapClassInst.heap32[r13 + numDefine2] = heapClassInst.heap32[r1 + numDefine2];
                heapClassInst.heap32[r13 + numDefine3] = heapClassInst.heap32[r1 + numDefine3];
                heapClassInst.heap32[r13 + numDefine4] = heapClassInst.heap32[r1 + numDefine4];
                heapClassInst.heap32[r13 + numDefine5] = heapClassInst.heap32[r1 + numDefine5];
                heapClassInst.heap32[r13 + numDefine6] = heapClassInst.heap32[r1 + numDefine6];
                heapClassInst.heap32[r13 + numDefine7] = heapClassInst.heap32[r1 + numDefine7];
                heapClassInst.heap32[r13 + numDefine8] = heapClassInst.heap32[r1 + numDefine8];
                heapClassInst.heap32[r13 + numDefine9] = heapClassInst.heap32[r1 + numDefine9];
                heapClassInst.heap32[r13 + numDefine10] = heapClassInst.heap32[r1 + numDefine10];
                heapClassInst.heap32[r13 + numDefine11] = heapClassInst.heap32[r1 + numDefine11];
                heapClassInst.heap32[r13 + numDefine12] = heapClassInst.heap32[r1 + numDefine12];
                heapClassInst.heap32[r13 + numDefine13] = heapClassInst.heap32[r1 + numDefine13];
                heapClassInst.heap32[r13 + numDefine14] = heapClassInst.heap32[r1 + numDefine14];
                heapClassInst.heap32[r13 + numDefine15] = heapClassInst.heap32[r1 + numDefine15];
                heapClassInst.heap32[r13 + numDefine16] = heapClassInst.heap32[r6];
                heapClassInst.heap32[r13 + numDefine17] = heapClassInst.heap32[r6 + 1];
                heapClassInst.heap32[r13 + numDefine18] = heapClassInst.heap32[r6 + numDefine2];
                heapClassInst.heap32[r13 + numDefine19] = heapClassInst.heap32[r6 + numDefine3];
                heapClassInst.heap32[r13 + numDefine20] = heapClassInst.heap32[r6 + numDefine4];
                heapClassInst.heap32[r13 + numDefine21] = heapClassInst.heap32[r6 + numDefine5];
                heapClassInst.heap32[r13 + numDefine22] = heapClassInst.heap32[r6 + numDefine6];
                heapClassInst.heap32[r13 + numDefine23] = heapClassInst.heap32[r6 + numDefine7];
                heapClassInst.heap32[r13 + numDefine24] = heapClassInst.heap32[r6 + numDefine8];
                heapClassInst.heap32[r13 + numDefine25] = heapClassInst.heap32[r6 + numDefine9];
                heapClassInst.heap32[r13 + numDefine26] = heapClassInst.heap32[r6 + numDefine10];
                heapClassInst.heap32[r13 + numDefine27] = heapClassInst.heap32[r6 + numDefine11];
                heapClassInst.heap32[r13 + numDefine28] = heapClassInst.heap32[r6 + numDefine12];
                heapClassInst.heap32[r13 + numDefine29] = heapClassInst.heap32[r6 + numDefine13];
                heapClassInst.heap32[r13 + numDefine30] = heapClassInst.heap32[r6 + numDefine14];
                heapClassInst.heap32[r13 + numDefine31] = heapClassInst.heap32[r6 + numDefine15];
                heapClassInst.heap32[g0] = r19;
                heapClassInst.heap32[g0 + 1] = r12;
                heapClassInst.heap32[g0 + numDefine2] = r10;
                heapClassInst.heap32[g0 + numDefine3] = 0;
                heapClassInst.heap32[g0 + numDefine4] = 0;
                zn17btGjkPairDetector16getClosestPointsERKN36btDiscreteCollisionDetectorInterface17ClosestPointInputERNS06ResultEP12btIDebugDrawb(i7);
                f6 = heapClassInst.heapFloat[r11 + numDefine5];
                r1 = heapClassInst.heapU8[sp + numDefineNeg136];
                r6 = sp + numDefineNeg128;
                heapClassInst.heapFloat[fp + numDefineNeg32] = (float) f6;
                f10 = heapClassInst.heapFloat[r11 + numDefine6];
                r10 = r6 >> numDefine2;
                heapClassInst.heapFloat[r10 + 1] = (float) f10;
                f13 = heapClassInst.heapFloat[r11 + numDefine7];
                heapClassInst.heapFloat[r10 + numDefine2] = (float) f13;
                f14 = heapClassInst.heapFloat[r11 + numDefine8];
                heapClassInst.heapFloat[r10 + numDefine3] = (float) f14;
                if (!(r1 == 0)) {
                    r1 = heapClassInst.heap32[fp + numDefine5];
                    f15 = heapClassInst.heapFloat[r11 + 1];
                    f16 = heapClassInst.heapFloat[r11 + numDefine2];
                    f17 = heapClassInst.heapFloat[r11 + numDefine3];
                    f18 = f12 * f15;
                    f19 = f8 * f16;
                    r12 = sp + numDefineNeg456;
                    f18 = f18 + f19;
                    f19 = f5 * f17;
                    f20 = heapClassInst.heapFloat[r11 + numDefine9];
                    f21 = heapClassInst.heapFloat[r11 + numDefine4];
                    f18 = f18 + f19;
                    r11 = (r12 + numDefine48) | 0;
                    repeat4: while (true) {
                        f19 = (float) numDefineFloat013;
                        if (f20 > f19) {
                            r13 = r1 >> numDefine2;
                            r14 = heapClassInst.heap32[r13 + numDefine42];
                            if (!(r14 == 0)) {
                                r15 = r14 >> numDefine2;
                                r15 = heapClassInst.heap32[r15];
                                r15 = r15 >> numDefine2;
                                r15 = heapClassInst.heap32[r15 + numDefine5];
                                r16 = sp + numDefineNeg80;
                                r17 = r16 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg20] = numDefine53216;
                                heapClassInst.heap32[r17 + 1] = numDefine53216;
                                heapClassInst.heap32[r17 + numDefine2] = numDefine53216;
                                heapClassInst.heap32[r17 + numDefine3] = 0;
                                heapClassInst.heap32[g0] = r14;
                                heapClassInst.heap32[g0 + 1] = r6;
                                heapClassInst.heap32[g0 + numDefine2] = numDefine20557;
                                heapClassInst.heap32[g0 + numDefine3] = r16;
                                functionTable.get(r15 >> numDefine2).accept(i7);
                            }
                            r2 = (r2 + 1) | 0;
                            if (r2 > numDefine64) {
                                break repeat1;
                            } else {
                                f6 = f12 * f15;
                                f10 = f8 * f16;
                                f6 = f6 + f10;
                                f10 = f5 * f17;
                                f18 = f6 + f10;
                                f6 = f18 + f1;
                                f10 = (float) numDefineFloat1257;
                                if (f6 <= f10) {
                                    break repeat1;
                                } else {
                                    f6 = f20 / f6;
                                    f19 = f9 + f6;
                                    f6 = 0;
                                    if (f19 < f6) {
                                        break repeat1;
                                    } else {
                                        f10 = 1;
                                        if (f19 > f10) {
                                            break repeat1;
                                        } else {
                                            if (f19 <= f9) {
                                                break repeat1;
                                            } else {
                                                heapClassInst.heap32[g0] = r5;
                                                heapClassInst.heapFloat[g0 + 1] = (float) f4;
                                                heapClassInst.heapFloat[g0 + numDefine2] = (float) f2;
                                                heapClassInst.heapFloat[g0 + numDefine3] = (float) f0;
                                                heapClassInst.heap32[g0 + numDefine4] = r3;
                                                heapClassInst.heapFloat[g0 + numDefine5] = (float) f19;
                                                heapClassInst.heap32[g0 + numDefine6] = r12;
                                                zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(i7);
                                                r14 = sp + numDefineNeg520;
                                                heapClassInst.heap32[g0] = r7;
                                                heapClassInst.heapFloat[g0 + 1] = (float) f3;
                                                heapClassInst.heapFloat[g0 + numDefine2] = (float) f11;
                                                heapClassInst.heapFloat[g0 + numDefine3] = (float) f7;
                                                heapClassInst.heap32[g0 + numDefine4] = r8;
                                                heapClassInst.heapFloat[g0 + numDefine5] = (float) f19;
                                                heapClassInst.heap32[g0 + numDefine6] = r14;
                                                zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(i7);
                                                r15 = heapClassInst.heap32[r13 + numDefine42];
                                                if (!(r15 == 0)) {
                                                    r16 = r15 >> numDefine2;
                                                    r16 = heapClassInst.heap32[r16];
                                                    r16 = r16 >> numDefine2;
                                                    r16 = heapClassInst.heap32[r16 + numDefine5];
                                                    r17 = sp + numDefineNeg64;
                                                    r19 = r17 >> numDefine2;
                                                    heapClassInst.heap32[fp + numDefineNeg16] = numDefine53216;
                                                    heapClassInst.heap32[r19 + 1] = 0;
                                                    heapClassInst.heap32[r19 + numDefine2] = 0;
                                                    heapClassInst.heap32[r19 + numDefine3] = 0;
                                                    heapClassInst.heap32[g0] = r15;
                                                    heapClassInst.heap32[g0 + 1] = r11;
                                                    heapClassInst.heap32[g0 + numDefine2] = numDefine20557;
                                                    heapClassInst.heap32[g0 + numDefine3] = r17;
                                                    functionTable.get(r16 >> numDefine2).accept(i7);
                                                }
                                                r15 = heapClassInst.heap32[r13];
                                                r15 = r15 >> numDefine2;
                                                r15 = heapClassInst.heap32[r15];
                                                heapClassInst.heap32[g0] = r1;
                                                heapClassInst.heapFloat[g0 + 1] = (float) f19;
                                                r16 = sp + numDefineNeg568;
                                                functionTable.get(r15 >> numDefine2).accept(i7);
                                                r15 = r16 >> numDefine2;
                                                heapClassInst.heap32[fp + numDefineNeg142] = r9;
                                                r17 = 0;
                                                heapClassInst.heap32[r15 + numDefine9] = numDefine44395;
                                                heapClassInst.heap8[sp + numDefineNeg528] = (byte) r17;
                                                r19 = heapClassInst.heap32[r0 + numDefine4];
                                                r20 = heapClassInst.heap32[r0 + numDefine3];
                                                r21 = heapClassInst.heap32[r0 + 1];
                                                r22 = heapClassInst.heap32[r0 + numDefine2];
                                                r23 = sp + numDefineNeg648;
                                                heapClassInst.heap32[fp + numDefineNeg162] = r18;
                                                r24 = r23 >> numDefine2;
                                                heapClassInst.heap32[r24 + 1] = 0;
                                                heapClassInst.heap32[r24 + numDefine2] = numDefine53216;
                                                heapClassInst.heap32[r24 + numDefine3] = 0;
                                                heapClassInst.heap32[r24 + numDefine4] = 0;
                                                heapClassInst.heap32[r24 + numDefine5] = r22;
                                                heapClassInst.heap32[r24 + numDefine6] = r21;
                                                heapClassInst.heap32[r24 + numDefine7] = r20;
                                                r21 = r20 >> numDefine2;
                                                heapClassInst.heap32[r24 + numDefine8] = r19;
                                                r22 = heapClassInst.heap32[r21 + 1];
                                                heapClassInst.heap32[r24 + numDefine9] = r22;
                                                r22 = r19 >> numDefine2;
                                                r25 = heapClassInst.heap32[r22 + 1];
                                                heapClassInst.heap32[r24 + numDefine10] = r25;
                                                r21 = heapClassInst.heap32[r21];
                                                r21 = r21 >> numDefine2;
                                                r21 = heapClassInst.heap32[r21 + numDefine11];
                                                heapClassInst.heap32[g0] = r20;
                                                functionTable.get(r21 >> numDefine2).accept(i7);
                                                heapClassInst.heapFloat[r24 + numDefine11] = (float) commonVariable.fg0;
                                                r20 = heapClassInst.heap32[r22];
                                                r20 = r20 >> numDefine2;
                                                r20 = heapClassInst.heap32[r20 + numDefine11];
                                                heapClassInst.heap32[g0] = r19;
                                                functionTable.get(r20 >> numDefine2).accept(i7);
                                                heapClassInst.heapFloat[r24 + numDefine12] = (float) commonVariable.fg0;
                                                heapClassInst.heap8[sp + numDefineNeg596] = (byte) r17;
                                                r19 = sp + numDefineNeg784;
                                                heapClassInst.heap32[r24 + numDefine15] = -1;
                                                r20 = r19 >> numDefine2;
                                                heapClassInst.heap32[r24 + numDefine18] = 1;
                                                heapClassInst.heap32[r20 + numDefine32] = numDefine44395;
                                                heapClassInst.heap32[r20 + numDefine33] = 0;
                                                r21 = r12 >> numDefine2;
                                                heapClassInst.heap32[fp + numDefineNeg196] = heapClassInst.heap32[fp + numDefineNeg114];
                                                heapClassInst.heap32[r20 + 1] = heapClassInst.heap32[r21 + 1];
                                                heapClassInst.heap32[r20 + numDefine2] = heapClassInst.heap32[r21 + numDefine2];
                                                heapClassInst.heap32[r20 + numDefine3] = heapClassInst.heap32[r21 + numDefine3];
                                                heapClassInst.heap32[r20 + numDefine4] = heapClassInst.heap32[r21 + numDefine4];
                                                heapClassInst.heap32[r20 + numDefine5] = heapClassInst.heap32[r21 + numDefine5];
                                                heapClassInst.heap32[r20 + numDefine6] = heapClassInst.heap32[r21 + numDefine6];
                                                heapClassInst.heap32[r20 + numDefine7] = heapClassInst.heap32[r21 + numDefine7];
                                                heapClassInst.heap32[r20 + numDefine8] = heapClassInst.heap32[r21 + numDefine8];
                                                heapClassInst.heap32[r20 + numDefine9] = heapClassInst.heap32[r21 + numDefine9];
                                                heapClassInst.heap32[r20 + numDefine10] = heapClassInst.heap32[r21 + numDefine10];
                                                heapClassInst.heap32[r20 + numDefine11] = heapClassInst.heap32[r21 + numDefine11];
                                                heapClassInst.heap32[r20 + numDefine12] = heapClassInst.heap32[r21 + numDefine12];
                                                heapClassInst.heap32[r20 + numDefine13] = heapClassInst.heap32[r21 + numDefine13];
                                                heapClassInst.heap32[r20 + numDefine14] = heapClassInst.heap32[r21 + numDefine14];
                                                heapClassInst.heap32[r20 + numDefine15] = heapClassInst.heap32[r21 + numDefine15];
                                                r14 = r14 >> numDefine2;
                                                heapClassInst.heap32[r20 + numDefine16] = heapClassInst.heap32[fp + numDefineNeg130];
                                                heapClassInst.heap32[r20 + numDefine17] = heapClassInst.heap32[r14 + 1];
                                                heapClassInst.heap32[r20 + numDefine18] = heapClassInst.heap32[r14 + numDefine2];
                                                heapClassInst.heap32[r20 + numDefine19] = heapClassInst.heap32[r14 + numDefine3];
                                                heapClassInst.heap32[r20 + numDefine20] = heapClassInst.heap32[r14 + numDefine4];
                                                heapClassInst.heap32[r20 + numDefine21] = heapClassInst.heap32[r14 + numDefine5];
                                                heapClassInst.heap32[r20 + numDefine22] = heapClassInst.heap32[r14 + numDefine6];
                                                heapClassInst.heap32[r20 + numDefine23] = heapClassInst.heap32[r14 + numDefine7];
                                                heapClassInst.heap32[r20 + numDefine24] = heapClassInst.heap32[r14 + numDefine8];
                                                heapClassInst.heap32[r20 + numDefine25] = heapClassInst.heap32[r14 + numDefine9];
                                                heapClassInst.heap32[r20 + numDefine26] = heapClassInst.heap32[r14 + numDefine10];
                                                heapClassInst.heap32[r20 + numDefine27] = heapClassInst.heap32[r14 + numDefine11];
                                                heapClassInst.heap32[r20 + numDefine28] = heapClassInst.heap32[r14 + numDefine12];
                                                heapClassInst.heap32[r20 + numDefine29] = heapClassInst.heap32[r14 + numDefine13];
                                                heapClassInst.heap32[r20 + numDefine30] = heapClassInst.heap32[r14 + numDefine14];
                                                heapClassInst.heap32[r20 + numDefine31] = heapClassInst.heap32[r14 + numDefine15];
                                                heapClassInst.heap32[g0] = r23;
                                                heapClassInst.heap32[g0 + 1] = r19;
                                                heapClassInst.heap32[g0 + numDefine2] = r16;
                                                heapClassInst.heap32[g0 + numDefine3] = 0;
                                                heapClassInst.heap32[g0 + numDefine4] = 0;
                                                zn17btGjkPairDetector16getClosestPointsERKN36btDiscreteCollisionDetectorInterface17ClosestPointInputERNS06ResultEP12btIDebugDrawb(i7);
                                                r14 = heapClassInst.heapU8[sp + numDefineNeg528];
                                                if (r14 != 0) {
                                                    f20 = heapClassInst.heapFloat[r15 + numDefine9];
                                                    if (f20 >= f6) {
                                                        f6 = heapClassInst.heapFloat[r15 + numDefine5];
                                                        heapClassInst.heapFloat[fp + numDefineNeg32] = (float) f6;
                                                        f10 = heapClassInst.heapFloat[r15 + numDefine6];
                                                        heapClassInst.heapFloat[r10 + 1] = (float) f10;
                                                        f13 = heapClassInst.heapFloat[r15 + numDefine7];
                                                        heapClassInst.heapFloat[r10 + numDefine2] = (float) f13;
                                                        f14 = heapClassInst.heapFloat[r15 + numDefine8];
                                                        heapClassInst.heapFloat[r10 + numDefine3] = (float) f14;
                                                        f15 = heapClassInst.heapFloat[r15 + 1];
                                                        f16 = heapClassInst.heapFloat[r15 + numDefine2];
                                                        f17 = heapClassInst.heapFloat[r15 + numDefine3];
                                                        f21 = heapClassInst.heapFloat[r15 + numDefine4];
                                                        heapClassInst.heap32[fp + numDefineNeg142] = r9;
                                                        f9 = f19;
                                                    } else {
                                                        label = numDefine14;
                                                        break repeat4;
                                                    }
                                                } else {
                                                    label = numDefine15;
                                                    break repeat4;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        } else {
                            label = numDefine18;
                            break repeat4;
                        }
                    }
                    switch (label) {
                        case numDefine18:
                            r0 = r1 >> numDefine2;
                            f0 = f18 + f1;
                            f1 = heapClassInst.heapFloat[r0 + numDefine43];
                            if (f0 <= f1) {
                                break repeat1;
                            } else {
                                heapClassInst.heapFloat[r0 + numDefine41] = (float) f9;
                                heapClassInst.heapFloat[r0 + numDefine33] = (float) f15;
                                heapClassInst.heapFloat[r0 + numDefine34] = (float) f16;
                                heapClassInst.heapFloat[r0 + numDefine35] = (float) f17;
                                heapClassInst.heapFloat[r0 + numDefine36] = (float) f21;
                                heapClassInst.heapFloat[r0 + numDefine37] = (float) f6;
                                heapClassInst.heapFloat[r0 + numDefine38] = (float) f10;
                                heapClassInst.heapFloat[r0 + numDefine39] = (float) f13;
                                heapClassInst.heapFloat[r0 + numDefine40] = (float) f14;
                                r0 = 1;
                                commonVariable.rg0 = r0;
                                return;
                            }
                        case numDefine14:
                            heapClassInst.heapFloat[r13 + numDefine41] = (float) f19;
                            f0 = heapClassInst.heapFloat[r15 + numDefine4];
                            f1 = heapClassInst.heapFloat[r15 + numDefine3];
                            f2 = heapClassInst.heapFloat[r15 + numDefine2];
                            heapClassInst.heap32[r13 + numDefine33] = heapClassInst.heap32[r15 + 1];
                            heapClassInst.heapFloat[r13 + numDefine34] = f2;
                            heapClassInst.heapFloat[r13 + numDefine35] = f1;
                            heapClassInst.heapFloat[r13 + numDefine36] = f0;
                            heapClassInst.heap32[r13 + numDefine37] = heapClassInst.heap32[r15 + numDefine5];
                            heapClassInst.heap32[r13 + numDefine38] = heapClassInst.heap32[r15 + numDefine6];
                            heapClassInst.heap32[r13 + numDefine39] = heapClassInst.heap32[r15 + numDefine7];
                            heapClassInst.heap32[r13 + numDefine40] = heapClassInst.heap32[r15 + numDefine8];
                            r17 = r4;
                            break;
                        default:
                            break;
                    }
                    heapClassInst.heap32[fp + numDefineNeg142] = r9;
                    r0 = r17 & numDefine255;
                    commonVariable.rg0 = r0;
                    return;
                }
            }
        } while (false);
        r0 = 0;
        commonVariable.rg0 = r0;
        return;
    }

    public static void zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg32;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        f0 = heapClassInst.heapFloat[fp + numDefine5];
        f1 = heapClassInst.heapFloat[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine6];
        f2 = heapClassInst.heapFloat[fp + numDefine2];
        f1 = f1 * f0;
        f3 = heapClassInst.heapFloat[r1 + numDefine12];
        f4 = heapClassInst.heapFloat[r1 + numDefine14];
        f5 = heapClassInst.heapFloat[r1 + numDefine13];
        f6 = heapClassInst.heapFloat[fp + numDefine3];
        f2 = f2 * f0;
        r1 = r2 >> numDefine2;
        f1 = f3 + f1;
        f3 = f6 * f0;
        f2 = f5 + f2;
        heapClassInst.heapFloat[r1 + numDefine12] = (float) f1;
        f1 = f4 + f3;
        heapClassInst.heapFloat[r1 + numDefine13] = (float) f2;
        r2 = heapClassInst.heap32[fp + numDefine4];
        heapClassInst.heapFloat[r1 + numDefine14] = (float) f1;
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine15] = 0;
        f1 = heapClassInst.heapFloat[r2];
        f2 = heapClassInst.heapFloat[r2 + 1];
        f3 = heapClassInst.heapFloat[r2 + numDefine2];
        f1 = f1 * f1;
        f2 = f2 * f2;
        f1 = f1 + f2;
        f2 = f3 * f3;
        f1 = f1 + f2;
        heapClassInst.heapFloat[g0] = (float) f1;
        sqrtf(i7);
        f1 = (float) commonVariable.fg0;
        f2 = f1 * f0;
        f3 = (float) numDefineFloat731;
        if (f2 > f3) {
            f1 = f3 / f0;
        }
        f2 = (float) numDefineFloat013;
        if (f1 >= f2) {
            f2 = (float) numDefineFloat05;
            f2 = f1 * f2;
            f2 = f2 * f0;
            heapClassInst.heapFloat[g0] = (float) f2;
            sinf(i7);
            f3 = heapClassInst.heapFloat[r2 + numDefine2];
            f2 = (float) (commonVariable.fg0 / f1);
            f5 = heapClassInst.heapFloat[r2 + 1];
            f6 = heapClassInst.heapFloat[r2];
            f4 = f3 * f2;
            f3 = f5 * f2;
            f2 = f6 * f2;
        } else {
            f2 = f0 * f0;
            f2 = f2 * f0;
            f3 = (float) numDefineNegFloat005;
            f2 = f2 * f3;
            f3 = (float) numDefineFloat05;
            f2 = f2 * f1;
            f3 = f0 * f3;
            f2 = f2 * f1;
            f4 = heapClassInst.heapFloat[r2 + numDefine2];
            f2 = f3 + f2;
            f3 = heapClassInst.heapFloat[r2 + 1];
            f5 = heapClassInst.heapFloat[r2];
            f4 = f4 * f2;
            f3 = f3 * f2;
            f2 = f5 * f2;
        }
        f0 = f1 * f0;
        f1 = (float) numDefineFloat05;
        f0 = f0 * f1;
        heapClassInst.heapFloat[g0] = (float) f0;
        cosf(i7);
        f0 = (float) commonVariable.fg0;
        r2 = sp + numDefineNeg16;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        znk11btMatrix3x311getRotationER12btQuaternion(i7);
        r0 = r2 >> numDefine2;
        f1 = heapClassInst.heapFloat[fp + numDefineNeg4];
        f5 = heapClassInst.heapFloat[r0 + numDefine3];
        f6 = heapClassInst.heapFloat[r0 + 1];
        f7 = heapClassInst.heapFloat[r0 + numDefine2];
        f8 = f0 * f6;
        f9 = f3 * f5;
        f10 = f0 * f1;
        f11 = f2 * f5;
        f12 = f0 * f7;
        f13 = f4 * f5;
        f8 = f8 + f9;
        f9 = f4 * f1;
        f10 = f10 + f11;
        f11 = f3 * f7;
        f0 = f0 * f5;
        f5 = f2 * f1;
        f12 = f12 + f13;
        f13 = f2 * f6;
        f8 = f8 + f9;
        f2 = f2 * f7;
        f9 = f10 + f11;
        f10 = f4 * f6;
        f2 = f8 - f2;
        f8 = f9 - f10;
        f0 = f0 - f5;
        f5 = f3 * f6;
        f6 = f12 + f13;
        f1 = f3 * f1;
        f1 = f6 - f1;
        f3 = f8 * f8;
        f6 = f2 * f2;
        f0 = f0 - f5;
        f4 = f4 * f7;
        f0 = f0 - f4;
        f3 = f3 + f6;
        f4 = f1 * f1;
        f3 = f3 + f4;
        f4 = f0 * f0;
        f3 = f3 + f4;
        heapClassInst.heapFloat[g0] = (float) f3;
        sqrtf(i7);
        f3 = (float) commonVariable.fg0;
        f4 = 0;
        if (f3 != f4) {
            f4 = 1;
            f3 = f4 / f3;
            f5 = f8 * f3;
            f2 = f2 * f3;
            f1 = f1 * f3;
            f6 = f5 * f5;
            f7 = f2 * f2;
            f0 = f0 * f3;
            f3 = f6 + f7;
            f6 = f1 * f1;
            f3 = f3 + f6;
            f6 = f0 * f0;
            f7 = numDefine2;
            f3 = f3 + f6;
            f3 = f7 / f3;
            f6 = f1 * f3;
            f7 = f2 * f3;
            f8 = f2 * f7;
            f1 = f1 * f6;
            f9 = f8 + f1;
            f9 = f4 - f9;
            f10 = f5 * f7;
            f11 = f0 * f6;
            f12 = f5 * f6;
            f7 = f0 * f7;
            f13 = f10 - f11;
            heapClassInst.heapFloat[r1] = (float) f9;
            f3 = f5 * f3;
            f9 = f12 + f7;
            heapClassInst.heapFloat[r1 + 1] = (float) f13;
            f5 = f5 * f3;
            heapClassInst.heapFloat[r1 + numDefine2] = (float) f9;
            f1 = f5 + f1;
            f9 = f10 + f11;
            heapClassInst.heap32[r1 + numDefine3] = 0;
            f2 = f2 * f6;
            f0 = f0 * f3;
            f1 = f4 - f1;
            heapClassInst.heapFloat[r1 + numDefine4] = (float) f9;
            f3 = f2 - f0;
            heapClassInst.heapFloat[r1 + numDefine5] = (float) f1;
            heapClassInst.heapFloat[r1 + numDefine6] = (float) f3;
            f1 = f12 - f7;
            heapClassInst.heap32[r1 + numDefine7] = 0;
            f3 = f5 + f8;
            f0 = f2 + f0;
            heapClassInst.heapFloat[r1 + numDefine8] = (float) f1;
            f1 = f4 - f3;
            heapClassInst.heapFloat[r1 + numDefine9] = (float) f0;
            heapClassInst.heapFloat[r1 + numDefine10] = (float) f1;
            heapClassInst.heap32[r1 + numDefine11] = 0;
            return;
        } else {
            r1 = twoEStr584;
            r0 = twoEStr685;
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = r0;
            heapClassInst.heap32[g0 + numDefine2] = numDefine188;
            assertNew(i7);
        }
    }

    public static void zn12btConvexCastD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv12btConvexCast;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn12btConvexCastD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv12btConvexCast;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn15btGjkConvexCastD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv12btConvexCast;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn15btGjkConvexCastD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv12btConvexCast;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn15btGjkConvexCast16calcTimeCast10Cast(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg288;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + 1];
        r2 = 0;
        r3 = r1 >> numDefine2;
        heapClassInst.heap8[r1 + numDefine312] = (byte) r2;
        r4 = 1;
        heapClassInst.heap32[r3] = 0;
        heapClassInst.heap8[r1 + numDefine356] = (byte) r4;
        heapClassInst.heap32[r3 + numDefine73] = numDefine44395;
        heapClassInst.heap32[r3 + numDefine74] = numDefine44395;
        heapClassInst.heap32[r3 + numDefine75] = numDefine44395;
        heapClassInst.heap32[r3 + numDefine76] = 0;
        heapClassInst.heap8[r1 + numDefine352] = (byte) r2;
        heapClassInst.heap32[r3 + numDefine84] = 0;
        heapClassInst.heap32[r3 + numDefine85] = 0;
        heapClassInst.heap32[r3 + numDefine86] = 0;
        heapClassInst.heap32[r3 + numDefine87] = 0;
        r3 = heapClassInst.heapU8[r1 + numDefine332];
        r4 = heapClassInst.heap32[fp + numDefine2];
        r5 = heapClassInst.heap32[fp + 1];
        r6 = heapClassInst.heap32[fp + numDefine4];
        r7 = heapClassInst.heap32[fp + numDefine3];
        r3 = r3 & numDefine240;
        r4 = r4 >> numDefine2;
        heapClassInst.heap8[r1 + numDefine332] = (byte) r3;
        r1 = r5 >> numDefine2;
        r3 = r6 >> numDefine2;
        r5 = r7 >> numDefine2;
        r6 = ztv16btPointCollector;
        f0 = heapClassInst.heapFloat[r4 + numDefine14];
        f1 = heapClassInst.heapFloat[r1 + numDefine14];
        f2 = heapClassInst.heapFloat[r3 + numDefine14];
        f3 = heapClassInst.heapFloat[r5 + numDefine14];
        f4 = heapClassInst.heapFloat[r4 + numDefine13];
        f5 = heapClassInst.heapFloat[r1 + numDefine13];
        f6 = heapClassInst.heapFloat[r3 + numDefine13];
        f7 = heapClassInst.heapFloat[r5 + numDefine13];
        f8 = heapClassInst.heapFloat[r4 + numDefine12];
        f9 = heapClassInst.heapFloat[r1 + numDefine12];
        f10 = heapClassInst.heapFloat[r3 + numDefine12];
        f11 = heapClassInst.heapFloat[r5 + numDefine12];
        r7 = sp + numDefineNeg48;
        r6 = (r6 + numDefine8) | 0;
        r8 = r7 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg12] = r6;
        heapClassInst.heap32[r8 + numDefine9] = numDefine44395;
        heapClassInst.heap8[sp + numDefineNeg8] = (byte) r2;
        r6 = heapClassInst.heap32[r0 + numDefine3];
        r9 = heapClassInst.heap32[r0 + numDefine2];
        r0 = heapClassInst.heap32[r0 + 1];
        r10 = ztv17btGjkPairDetector;
        r11 = sp + numDefineNeg128;
        r10 = (r10 + numDefine8) | 0;
        heapClassInst.heap32[fp + numDefineNeg32] = r10;
        r10 = r11 >> numDefine2;
        heapClassInst.heap32[r10 + 1] = 0;
        heapClassInst.heap32[r10 + numDefine2] = numDefine53216;
        heapClassInst.heap32[r10 + numDefine3] = 0;
        heapClassInst.heap32[r10 + numDefine4] = 0;
        heapClassInst.heap32[r10 + numDefine5] = 0;
        heapClassInst.heap32[r10 + numDefine6] = r0;
        heapClassInst.heap32[r10 + numDefine7] = r9;
        r0 = r9 >> numDefine2;
        heapClassInst.heap32[r10 + numDefine8] = r6;
        r12 = heapClassInst.heap32[r0 + 1];
        heapClassInst.heap32[r10 + numDefine9] = r12;
        r12 = r6 >> numDefine2;
        r13 = heapClassInst.heap32[r12 + 1];
        heapClassInst.heap32[r10 + numDefine10] = r13;
        r0 = heapClassInst.heap32[r0];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine11];
        heapClassInst.heap32[g0] = r9;
        functionTable.get(r0 >> numDefine2).accept(i7);
        heapClassInst.heapFloat[r10 + numDefine11] = (float) commonVariable.fg0;
        r0 = heapClassInst.heap32[r12];
        r0 = r0 >> numDefine2;
        r0 = heapClassInst.heap32[r0 + numDefine11];
        heapClassInst.heap32[g0] = r6;
        functionTable.get(r0 >> numDefine2).accept(i7);
        heapClassInst.heapFloat[r10 + numDefine12] = (float) commonVariable.fg0;
        heapClassInst.heap8[sp + numDefineNeg76] = (byte) r2;
        r0 = sp + numDefineNeg264;
        heapClassInst.heap32[r10 + numDefine15] = -1;
        r6 = r0 >> numDefine2;
        heapClassInst.heap32[r10 + numDefine18] = 1;
        heapClassInst.heap32[r6 + numDefine32] = numDefine44395;
        heapClassInst.heap32[r6 + numDefine33] = 0;
        heapClassInst.heap32[fp + numDefineNeg66] = heapClassInst.heap32[r1];
        heapClassInst.heap32[r6 + 1] = heapClassInst.heap32[r1 + 1];
        heapClassInst.heap32[r6 + numDefine2] = heapClassInst.heap32[r1 + numDefine2];
        heapClassInst.heap32[r6 + numDefine3] = heapClassInst.heap32[r1 + numDefine3];
        heapClassInst.heap32[r6 + numDefine4] = heapClassInst.heap32[r1 + numDefine4];
        heapClassInst.heap32[r6 + numDefine5] = heapClassInst.heap32[r1 + numDefine5];
        heapClassInst.heap32[r6 + numDefine6] = heapClassInst.heap32[r1 + numDefine6];
        heapClassInst.heap32[r6 + numDefine7] = heapClassInst.heap32[r1 + numDefine7];
        heapClassInst.heap32[r6 + numDefine8] = heapClassInst.heap32[r1 + numDefine8];
        heapClassInst.heap32[r6 + numDefine9] = heapClassInst.heap32[r1 + numDefine9];
        heapClassInst.heap32[r6 + numDefine10] = heapClassInst.heap32[r1 + numDefine10];
        heapClassInst.heap32[r6 + numDefine11] = heapClassInst.heap32[r1 + numDefine11];
        heapClassInst.heap32[r6 + numDefine12] = heapClassInst.heap32[r1 + numDefine12];
        heapClassInst.heap32[r6 + numDefine13] = heapClassInst.heap32[r1 + numDefine13];
        heapClassInst.heap32[r6 + numDefine14] = heapClassInst.heap32[r1 + numDefine14];
        heapClassInst.heap32[r6 + numDefine15] = heapClassInst.heap32[r1 + numDefine15];
        heapClassInst.heap32[r6 + numDefine16] = heapClassInst.heap32[r5];
        heapClassInst.heap32[r6 + numDefine17] = heapClassInst.heap32[r5 + 1];
        heapClassInst.heap32[r6 + numDefine18] = heapClassInst.heap32[r5 + numDefine2];
        heapClassInst.heap32[r6 + numDefine19] = heapClassInst.heap32[r5 + numDefine3];
        heapClassInst.heap32[r6 + numDefine20] = heapClassInst.heap32[r5 + numDefine4];
        heapClassInst.heap32[r6 + numDefine21] = heapClassInst.heap32[r5 + numDefine5];
        heapClassInst.heap32[r6 + numDefine22] = heapClassInst.heap32[r5 + numDefine6];
        heapClassInst.heap32[r6 + numDefine23] = heapClassInst.heap32[r5 + numDefine7];
        heapClassInst.heap32[r6 + numDefine24] = heapClassInst.heap32[r5 + numDefine8];
        heapClassInst.heap32[r6 + numDefine25] = heapClassInst.heap32[r5 + numDefine9];
        heapClassInst.heap32[r6 + numDefine26] = heapClassInst.heap32[r5 + numDefine10];
        heapClassInst.heap32[r6 + numDefine27] = heapClassInst.heap32[r5 + numDefine11];
        heapClassInst.heap32[r6 + numDefine28] = heapClassInst.heap32[r5 + numDefine12];
        heapClassInst.heap32[r6 + numDefine29] = heapClassInst.heap32[r5 + numDefine13];
        heapClassInst.heap32[r6 + numDefine30] = heapClassInst.heap32[r5 + numDefine14];
        heapClassInst.heap32[r6 + numDefine31] = heapClassInst.heap32[r5 + numDefine15];
        heapClassInst.heap32[g0] = r11;
        heapClassInst.heap32[g0 + 1] = r0;
        heapClassInst.heap32[g0 + numDefine2] = r7;
        heapClassInst.heap32[g0 + numDefine3] = 0;
        heapClassInst.heap32[g0 + numDefine4] = 0;
        zn17btGjkPairDetector16getClosestPointsERKN36btDiscreteCollisionDetectorInterface17ClosestPointInputERNS06ResultEP12btIDebugDrawb(i7);
        r9 = heapClassInst.heapU8[sp + numDefineNeg8];
        repeat1: do {
            if (!(r9 == 0)) {
                f0 = f0 - f1;
                f1 = f2 - f3;
                f2 = f4 - f5;
                f3 = f6 - f7;
                f4 = f8 - f9;
                f5 = f10 - f11;
                r9 = heapClassInst.heap32[fp + numDefine5];
                f0 = f0 - f1;
                f1 = f2 - f3;
                f2 = f4 - f5;
                f3 = heapClassInst.heapFloat[r8 + numDefine8];
                f4 = heapClassInst.heapFloat[r8 + numDefine7];
                f5 = heapClassInst.heapFloat[r8 + numDefine6];
                f6 = heapClassInst.heapFloat[r8 + numDefine5];
                f7 = heapClassInst.heapFloat[r8 + numDefine9];
                f8 = heapClassInst.heapFloat[r8 + 1];
                f9 = heapClassInst.heapFloat[r8 + numDefine2];
                f10 = heapClassInst.heapFloat[r8 + numDefine3];
                f11 = heapClassInst.heapFloat[r8 + numDefine4];
                f12 = 0;
                repeat3: while (true) {
                    f13 = (float) numDefineFloat013;
                    if (f7 > f13) {
                        r2 = (r2 + 1) | 0;
                        if (r2 > numDefine32) {
                            break repeat1;
                        } else {
                            f3 = f2 * f8;
                            f4 = f1 * f9;
                            f3 = f3 + f4;
                            f4 = f0 * f10;
                            f3 = f3 + f4;
                            f3 = f7 / f3;
                            f13 = f12 - f3;
                            f3 = 0;
                            if (f13 < f3) {
                                break repeat1;
                            } else {
                                f4 = 1;
                                if (f13 > f4) {
                                    break repeat1;
                                } else {
                                    if (f13 <= f12) {
                                        break repeat1;
                                    } else {
                                        r10 = r9 >> numDefine2;
                                        r12 = heapClassInst.heap32[r10];
                                        r12 = r12 >> numDefine2;
                                        r12 = heapClassInst.heap32[r12];
                                        heapClassInst.heap32[g0] = r9;
                                        heapClassInst.heapFloat[g0 + 1] = (float) f13;
                                        functionTable.get(r12 >> numDefine2).accept(i7);
                                        f5 = heapClassInst.heapFloat[r4 + numDefine12];
                                        f6 = heapClassInst.heapFloat[r1 + numDefine12];
                                        f4 = f4 - f13;
                                        f6 = f6 * f4;
                                        f5 = f5 * f13;
                                        f5 = f6 + f5;
                                        heapClassInst.heapFloat[r6 + numDefine12] = (float) f5;
                                        f5 = heapClassInst.heapFloat[r1 + numDefine13];
                                        f6 = heapClassInst.heapFloat[r4 + numDefine13];
                                        f5 = f5 * f4;
                                        f6 = f6 * f13;
                                        f5 = f5 + f6;
                                        heapClassInst.heapFloat[r6 + numDefine13] = (float) f5;
                                        f5 = heapClassInst.heapFloat[r1 + numDefine14];
                                        f6 = heapClassInst.heapFloat[r4 + numDefine14];
                                        f5 = f5 * f4;
                                        f6 = f6 * f13;
                                        f5 = f5 + f6;
                                        heapClassInst.heapFloat[r6 + numDefine14] = (float) f5;
                                        f5 = heapClassInst.heapFloat[r5 + numDefine12];
                                        f6 = heapClassInst.heapFloat[r3 + numDefine12];
                                        f5 = f5 * f4;
                                        f6 = f6 * f13;
                                        f5 = f5 + f6;
                                        heapClassInst.heapFloat[r6 + numDefine28] = (float) f5;
                                        f5 = heapClassInst.heapFloat[r5 + numDefine13];
                                        f6 = heapClassInst.heapFloat[r3 + numDefine13];
                                        f5 = f5 * f4;
                                        f6 = f6 * f13;
                                        f5 = f5 + f6;
                                        heapClassInst.heapFloat[r6 + numDefine29] = (float) f5;
                                        f5 = heapClassInst.heapFloat[r5 + numDefine14];
                                        f6 = heapClassInst.heapFloat[r3 + numDefine14];
                                        f4 = f5 * f4;
                                        f5 = f6 * f13;
                                        f4 = f4 + f5;
                                        heapClassInst.heapFloat[r6 + numDefine30] = (float) f4;
                                        heapClassInst.heap32[g0] = r11;
                                        heapClassInst.heap32[g0 + 1] = r0;
                                        heapClassInst.heap32[g0 + numDefine2] = r7;
                                        heapClassInst.heap32[g0 + numDefine3] = 0;
                                        heapClassInst.heap32[g0 + numDefine4] = 0;
                                        zn17btGjkPairDetector16getClosestPointsERKN36btDiscreteCollisionDetectorInterface17ClosestPointInputERNS06ResultEP12btIDebugDrawb(i7);
                                        r12 = heapClassInst.heapU8[sp + numDefineNeg8];
                                        if (r12 == 0) {
                                            break repeat1;
                                        } else {
                                            f7 = heapClassInst.heapFloat[r8 + numDefine9];
                                            if (f7 >= f3) {
                                                f6 = heapClassInst.heapFloat[r8 + numDefine5];
                                                f5 = heapClassInst.heapFloat[r8 + numDefine6];
                                                f4 = heapClassInst.heapFloat[r8 + numDefine7];
                                                f3 = heapClassInst.heapFloat[r8 + numDefine8];
                                                f8 = heapClassInst.heapFloat[r8 + 1];
                                                f9 = heapClassInst.heapFloat[r8 + numDefine2];
                                                f10 = heapClassInst.heapFloat[r8 + numDefine3];
                                                f11 = heapClassInst.heapFloat[r8 + numDefine4];
                                                f12 = f13;
                                            } else {
                                                label = numDefine8;
                                                break repeat3;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    } else {
                        label = numDefine11;
                        break repeat3;
                    }
                }
                switch (label) {
                    case numDefine11:
                        r0 = r9 >> numDefine2;
                        f2 = f8 * f2;
                        f1 = f9 * f1;
                        f7 = heapClassInst.heapFloat[r0 + numDefine43];
                        f1 = f2 + f1;
                        f0 = f10 * f0;
                        f0 = f1 + f0;
                        f1 = -f7;
                        if (f0 >= f1) {
                            break repeat1;
                        } else {
                            heapClassInst.heapFloat[r0 + numDefine41] = (float) f12;
                            heapClassInst.heapFloat[r0 + numDefine33] = (float) f8;
                            heapClassInst.heapFloat[r0 + numDefine34] = (float) f9;
                            heapClassInst.heapFloat[r0 + numDefine35] = (float) f10;
                            heapClassInst.heapFloat[r0 + numDefine36] = (float) f11;
                            heapClassInst.heapFloat[r0 + numDefine37] = (float) f6;
                            heapClassInst.heapFloat[r0 + numDefine38] = (float) f5;
                            heapClassInst.heapFloat[r0 + numDefine39] = (float) f4;
                            heapClassInst.heapFloat[r0 + numDefine40] = (float) f3;
                        }
                        break;
                    case numDefine8:
                        heapClassInst.heapFloat[r10 + numDefine41] = (float) f13;
                        f0 = heapClassInst.heapFloat[r8 + numDefine4];
                        f1 = heapClassInst.heapFloat[r8 + numDefine3];
                        f2 = heapClassInst.heapFloat[r8 + numDefine2];
                        heapClassInst.heap32[r10 + numDefine33] = heapClassInst.heap32[r8 + 1];
                        heapClassInst.heapFloat[r10 + numDefine34] = (float) f2;
                        heapClassInst.heapFloat[r10 + numDefine35] = (float) f1;
                        heapClassInst.heapFloat[r10 + numDefine36] = (float) f0;
                        heapClassInst.heap32[r10 + numDefine37] = heapClassInst.heap32[r8 + numDefine5];
                        heapClassInst.heap32[r10 + numDefine38] = heapClassInst.heap32[r8 + numDefine6];
                        heapClassInst.heap32[r10 + numDefine39] = heapClassInst.heap32[r8 + numDefine7];
                        heapClassInst.heap32[r10 + numDefine40] = heapClassInst.heap32[r8 + numDefine8];
                        break;
                    default:
                        break;
                }
                r0 = 1;
                commonVariable.rg0 = r0;
                return;
            }
        } while (false);
        r0 = 0;
        commonVariable.rg0 = r0;
        return;
    }

    public static void zn12gjkepa2Impl3GJK13projectoriginERK9btVector3S3PfRj(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        f0 = heapClassInst.heapFloat[r1 + 1];
        f1 = heapClassInst.heapFloat[r0 + 1];
        f2 = heapClassInst.heapFloat[r1];
        f3 = heapClassInst.heapFloat[r0];
        f1 = f1 - f0;
        f3 = f3 - f2;
        f4 = heapClassInst.heapFloat[r1 + numDefine2];
        f5 = heapClassInst.heapFloat[r0 + numDefine2];
        f5 = f5 - f4;
        f6 = f3 * f3;
        f7 = f1 * f1;
        f6 = f6 + f7;
        f7 = f5 * f5;
        f6 = f6 + f7;
        f7 = 0;
        if (f6 <= f7) {
            f0 = -1;
            commonVariable.fg0 = f0;
            return;
        } else {
            r2 = heapClassInst.heap32[fp + numDefine2];
            r3 = heapClassInst.heap32[fp + numDefine3];
            f2 = f2 * f3;
            f0 = f0 * f1;
            f0 = f2 + f0;
            f2 = f4 * f5;
            f0 = f0 + f2;
            f0 = -f0;
            f0 = f0 / f6;
            f2 = 1;
            if (f0 < f2) {
                if (f0 > f7) {
                    r0 = r2 >> numDefine2;
                    f2 = f2 - f0;
                    heapClassInst.heapFloat[r0 + 1] = (float) f0;
                    r2 = r3 >> numDefine2;
                    heapClassInst.heapFloat[r0] = (float) f2;
                    heapClassInst.heap32[r2] = numDefine3;
                    f2 = heapClassInst.heapFloat[r1];
                    f3 = f3 * f0;
                    f4 = heapClassInst.heapFloat[r1 + 1];
                    f1 = f1 * f0;
                    f2 = f2 + f3;
                    f1 = f4 + f1;
                    f3 = heapClassInst.heapFloat[r1 + numDefine2];
                    f0 = f5 * f0;
                    f0 = f3 + f0;
                    f2 = f2 * f2;
                    f1 = f1 * f1;
                    f1 = f2 + f1;
                    f0 = f0 * f0;
                    f0 = f1 + f0;
                    commonVariable.fg0 = f0;
                    return;
                } else {
                    r2 = r2 >> numDefine2;
                    heapClassInst.heap32[r2] = numDefine53216;
                    r3 = r3 >> numDefine2;
                    heapClassInst.heap32[r2 + 1] = 0;
                    heapClassInst.heap32[r3] = 1;
                    f0 = heapClassInst.heapFloat[r1];
                    f1 = heapClassInst.heapFloat[r1 + 1];
                    f2 = heapClassInst.heapFloat[r1 + numDefine2];
                }
            } else {
                r1 = r2 >> numDefine2;
                heapClassInst.heap32[r1] = 0;
                r2 = r3 >> numDefine2;
                heapClassInst.heap32[r1 + 1] = numDefine53216;
                heapClassInst.heap32[r2] = numDefine2;
                f0 = heapClassInst.heapFloat[r0];
                f1 = heapClassInst.heapFloat[r0 + 1];
                f2 = heapClassInst.heapFloat[r0 + numDefine2];
            }
            f0 = f0 * f0;
            f1 = f1 * f1;
            f0 = f0 + f1;
            f1 = f2 * f2;
            f0 = f0 + f1;
            commonVariable.fg0 = f0;
            return;
        }
    }

    public static void zn12gjkepa2ConvexShapeRK11btTransform(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine4];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[fp + numDefine5];
        heapClassInst.heap32[r0] = 0;
        heapClassInst.heap32[r0 + 1] = 0;
        heapClassInst.heap32[r0 + numDefine2] = 0;
        heapClassInst.heap32[r0 + numDefine3] = 0;
        heapClassInst.heap32[r0 + numDefine4] = 0;
        heapClassInst.heap32[r0 + numDefine5] = 0;
        heapClassInst.heap32[r0 + numDefine6] = 0;
        heapClassInst.heap32[r0 + numDefine7] = 0;
        heapClassInst.heap32[r0 + numDefine8] = 0;
        r0 = r1 >> numDefine2;
        r1 = heapClassInst.heap32[fp];
        r2 = heapClassInst.heap32[fp + numDefine3];
        r3 = heapClassInst.heap32[fp + 1];
        r4 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[r0] = r1;
        r1 = r2 >> numDefine2;
        heapClassInst.heap32[r0 + 1] = r4;
        r2 = r3 >> numDefine2;
        f0 = heapClassInst.heapFloat[r2];
        f1 = heapClassInst.heapFloat[r1];
        f2 = heapClassInst.heapFloat[r2 + numDefine4];
        f3 = heapClassInst.heapFloat[r1 + numDefine4];
        f4 = heapClassInst.heapFloat[r2 + 1];
        f5 = heapClassInst.heapFloat[r2 + numDefine5];
        f6 = f1 * f0;
        f7 = f3 * f2;
        f8 = heapClassInst.heapFloat[r2 + numDefine8];
        f9 = heapClassInst.heapFloat[r1 + numDefine8];
        f10 = heapClassInst.heapFloat[r1 + numDefine2];
        f11 = heapClassInst.heapFloat[r2 + numDefine2];
        f12 = heapClassInst.heapFloat[r1 + 1];
        f13 = heapClassInst.heapFloat[r1 + numDefine6];
        f14 = heapClassInst.heapFloat[r2 + numDefine6];
        f15 = heapClassInst.heapFloat[r1 + numDefine5];
        f16 = heapClassInst.heapFloat[r1 + numDefine10];
        f17 = heapClassInst.heapFloat[r2 + numDefine10];
        f18 = heapClassInst.heapFloat[r2 + numDefine9];
        f19 = heapClassInst.heapFloat[r1 + numDefine9];
        f20 = f1 * f4;
        f21 = f3 * f5;
        f6 = f6 + f7;
        f7 = f9 * f8;
        f1 = f1 * f11;
        f3 = f3 * f14;
        f20 = f20 + f21;
        f21 = f9 * f18;
        f6 = f6 + f7;
        f1 = f1 + f3;
        f3 = f9 * f17;
        f7 = f20 + f21;
        heapClassInst.heapFloat[r0 + numDefine2] = (float) f6;
        f6 = f12 * f0;
        f9 = f15 * f2;
        f1 = f1 + f3;
        heapClassInst.heapFloat[r0 + numDefine3] = (float) f7;
        heapClassInst.heapFloat[r0 + numDefine4] = (float) f1;
        f1 = f12 * f4;
        f3 = f15 * f5;
        f6 = f6 + f9;
        f7 = f19 * f8;
        f9 = f12 * f11;
        f12 = f15 * f14;
        f1 = f1 + f3;
        f3 = f19 * f18;
        f6 = f6 + f7;
        heapClassInst.heap32[r0 + numDefine5] = 0;
        f7 = f9 + f12;
        f9 = f19 * f17;
        f1 = f1 + f3;
        heapClassInst.heapFloat[r0 + numDefine6] = (float) f6;
        f0 = f10 * f0;
        f2 = f13 * f2;
        f3 = f7 + f9;
        heapClassInst.heapFloat[r0 + numDefine7] = (float) f1;
        heapClassInst.heapFloat[r0 + numDefine8] = (float) f3;
        f1 = f10 * f4;
        f3 = f13 * f5;
        f0 = f0 + f2;
        f2 = f16 * f8;
        f4 = f10 * f11;
        f5 = f13 * f14;
        f1 = f1 + f3;
        f3 = f16 * f18;
        f0 = f0 + f2;
        heapClassInst.heap32[r0 + numDefine9] = 0;
        f2 = f4 + f5;
        f4 = f16 * f17;
        f1 = f1 + f3;
        heapClassInst.heapFloat[r0 + numDefine10] = (float) f0;
        f0 = f2 + f4;
        heapClassInst.heapFloat[r0 + numDefine11] = (float) f1;
        heapClassInst.heapFloat[r0 + numDefine12] = (float) f0;
        heapClassInst.heap32[r0 + numDefine13] = 0;
        f0 = heapClassInst.heapFloat[r2];
        f1 = heapClassInst.heapFloat[r1];
        f2 = heapClassInst.heapFloat[r2 + numDefine4];
        f3 = heapClassInst.heapFloat[r1 + numDefine4];
        f4 = heapClassInst.heapFloat[r1 + 1];
        f5 = heapClassInst.heapFloat[r1 + numDefine5];
        f6 = f0 * f1;
        f7 = f2 * f3;
        f8 = heapClassInst.heapFloat[r2 + numDefine8];
        f9 = heapClassInst.heapFloat[r1 + numDefine8];
        f10 = heapClassInst.heapFloat[r2 + numDefine2];
        f11 = heapClassInst.heapFloat[r2 + numDefine6];
        f12 = heapClassInst.heapFloat[r2 + 1];
        f13 = heapClassInst.heapFloat[r1 + numDefine2];
        f14 = heapClassInst.heapFloat[r2 + numDefine5];
        f15 = heapClassInst.heapFloat[r1 + numDefine6];
        f16 = heapClassInst.heapFloat[r2 + numDefine10];
        f17 = heapClassInst.heapFloat[r1 + numDefine10];
        f18 = heapClassInst.heapFloat[r2 + numDefine9];
        f19 = heapClassInst.heapFloat[r1 + numDefine9];
        f20 = f0 * f4;
        f21 = f2 * f5;
        f6 = f6 + f7;
        f7 = f8 * f9;
        f22 = heapClassInst.heapFloat[r1 + numDefine14];
        f23 = heapClassInst.heapFloat[r2 + numDefine14];
        f24 = heapClassInst.heapFloat[r1 + numDefine13];
        f25 = heapClassInst.heapFloat[r2 + numDefine13];
        f26 = heapClassInst.heapFloat[r1 + numDefine12];
        f27 = heapClassInst.heapFloat[r2 + numDefine12];
        f28 = f0 * f13;
        f29 = f2 * f15;
        f20 = f20 + f21;
        f21 = f8 * f19;
        f6 = f6 + f7;
        f7 = f28 + f29;
        f28 = f8 * f17;
        f20 = f20 + f21;
        heapClassInst.heapFloat[r0 + numDefine14] = (float) f6;
        f6 = f12 * f1;
        f21 = f14 * f3;
        f7 = f7 + f28;
        heapClassInst.heapFloat[r0 + numDefine15] = (float) f20;
        heapClassInst.heapFloat[r0 + numDefine16] = (float) f7;
        f7 = f12 * f4;
        f20 = f14 * f5;
        f6 = f6 + f21;
        f21 = f18 * f9;
        f28 = f12 * f13;
        f29 = f14 * f15;
        f7 = f7 + f20;
        f20 = f18 * f19;
        f6 = f6 + f21;
        heapClassInst.heap32[r0 + numDefine17] = 0;
        f21 = f28 + f29;
        f28 = f18 * f17;
        f7 = f7 + f20;
        heapClassInst.heapFloat[r0 + numDefine18] = (float) f6;
        f1 = f10 * f1;
        f3 = f11 * f3;
        f6 = f21 + f28;
        heapClassInst.heapFloat[r0 + numDefine19] = (float)  f7;
        heapClassInst.heapFloat[r0 + numDefine20] = f6;
        f4 = f10 * f4;
        f5 = f11 * f5;
        f1 = f1 + f3;
        f3 = f16 * f9;
        f6 = f10 * f13;
        f7 = f11 * f15;
        f4 = f4 + f5;
        f5 = f16 * f19;
        f1 = f1 + f3;
        heapClassInst.heap32[r0 + numDefine21] = 0;
        f3 = f26 - f27;
        f9 = f24 - f25;
        f6 = f6 + f7;
        f7 = f16 * f17;
        f4 = f4 + f5;
        heapClassInst.heapFloat[r0 + numDefine22] = f1;
        f1 = f22 - f23;
        f0 = f0 * f3;
        f2 = f2 * f9;
        f5 = f6 + f7;
        heapClassInst.heapFloat[r0 + numDefine23] = f4;
        heapClassInst.heapFloat[r0 + numDefine24] = f5;
        f4 = f12 * f3;
        f5 = f14 * f9;
        f0 = f0 + f2;
        f2 = f8 * f1;
        f3 = f10 * f3;
        f6 = f11 * f9;
        f4 = f4 + f5;
        f5 = f18 * f1;
        f0 = f0 + f2;
        heapClassInst.heap32[r0 + numDefine25] = 0;
        f2 = f3 + f6;
        f1 = f16 * f1;
        f3 = f4 + f5;
        heapClassInst.heapFloat[r0 + numDefine26] = f0;
        f0 = f2 + f1;
        heapClassInst.heapFloat[r0 + numDefine27] = f3;
        heapClassInst.heapFloat[r0 + numDefine28] = f0;
        heapClassInst.heap32[r0 + numDefine29] = 0;
        r1 = heapClassInst.heap32[fp + numDefine6];
        if (r1 == 0) {
            r1 = swriteIndex.znk13btConvexShape44localGetSupportVertexWithoutMarginNonVirtualERK9btVector3Index;
        } else {
            r1 = swriteIndex.znk13btConvexShape31localGetSupportVertexNonVirtualERK9btVector3Index;
        }
        heapClassInst.heap32[r0 + numDefine30] = r1;
        heapClassInst.heap32[r0 + numDefine31] = 0;
        return;
    }

    public static void znk12gjkepa2Impl3GJK10getsupportERK9btVector3RNS03sSVE(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg64;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r0 = r0 >> numDefine2;
        f0 = heapClassInst.heapFloat[r0];
        f1 = heapClassInst.heapFloat[r0 + 1];
        f2 = heapClassInst.heapFloat[r0 + numDefine2];
        f0 = f0 * f0;
        f1 = f1 * f1;
        f0 = f0 + f1;
        f1 = f2 * f2;
        f0 = f0 + f1;
        heapClassInst.heapFloat[g0] = f0;
        sqrtf(i7);
        f1 = 1;
        r1 = heapClassInst.heap32[fp + numDefine2];
        f0 = (float) (f1 / commonVariable.fg0);
        f1 = heapClassInst.heapFloat[r0 + numDefine2];
        f2 = heapClassInst.heapFloat[r0 + 1];
        f3 = heapClassInst.heapFloat[r0];
        f3 = f3 * f0;
        r0 = r1 >> numDefine2;
        f2 = f2 * f0;
        heapClassInst.heapFloat[r0] = f3;
        f0 = f1 * f0;
        heapClassInst.heapFloat[r0 + 1] = f2;
        r2 = heapClassInst.heap32[fp];
        heapClassInst.heapFloat[r0 + numDefine2] = f0;
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r0 + numDefine3] = 0;
        r3 = heapClassInst.heap32[r2 + numDefine30];
        f0 = -f0;
        f1 = -f2;
        f2 = -f3;
        r4 = heapClassInst.heap32[r2 + 1];
        r5 = heapClassInst.heap32[r2 + numDefine31];
        r6 = r3 & 1;
        if (r6 != 0) {
            r6 = (r4 + r5) | 0;
            r6 = r6 >> numDefine2;
            r6 = heapClassInst.heap32[r6];
            r3 = (r6 + r3) | 0;
            r3 = (r3 + -1) | 0;
            r3 = r3 >> numDefine2;
            r3 = heapClassInst.heap32[r3];
        }
        f3 = heapClassInst.heapFloat[r2 + numDefine2];
        f4 = heapClassInst.heapFloat[r2 + numDefine3];
        f5 = heapClassInst.heapFloat[r2 + numDefine6];
        f6 = heapClassInst.heapFloat[r2 + numDefine7];
        f3 = f3 * f2;
        f4 = f4 * f1;
        f7 = heapClassInst.heapFloat[r2 + numDefine4];
        f8 = heapClassInst.heapFloat[r2 + numDefine10];
        f9 = heapClassInst.heapFloat[r2 + numDefine11];
        f10 = heapClassInst.heapFloat[r2 + numDefine12];
        f11 = heapClassInst.heapFloat[r2 + numDefine8];
        f5 = f5 * f2;
        f6 = f6 * f1;
        f3 = f3 + f4;
        f4 = f7 * f0;
        r6 = sp + numDefineNeg16;
        f2 = f8 * f2;
        f1 = f9 * f1;
        f5 = f5 + f6;
        f6 = f11 * f0;
        f3 = f3 + f4;
        r7 = r6 >> numDefine2;
        f1 = f2 + f1;
        f0 = f10 * f0;
        f2 = f5 + f6;
        heapClassInst.heapFloat[fp + numDefineNeg4] = f3;
        f0 = f1 + f0;
        heapClassInst.heapFloat[r7 + 1] = f2;
        heapClassInst.heapFloat[r7 + numDefine2] = f0;
        heapClassInst.heap32[r7 + numDefine3] = 0;
        r7 = sp + numDefineNeg32;
        r4 = (r4 + r5) | 0;
        heapClassInst.heap32[g0] = r7;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = r6;
        functionTable.get(r3 >> numDefine2).accept(i7);
        r3 = r7 >> numDefine2;
        f0 = heapClassInst.heapFloat[r2 + numDefine22];
        f1 = heapClassInst.heapFloat[fp + numDefineNeg8];
        f2 = heapClassInst.heapFloat[r2 + numDefine18];
        f3 = heapClassInst.heapFloat[r2 + numDefine14];
        f4 = heapClassInst.heapFloat[r2 + numDefine23];
        f5 = heapClassInst.heapFloat[r3 + 1];
        f6 = heapClassInst.heapFloat[r2 + numDefine19];
        f7 = heapClassInst.heapFloat[r2 + numDefine15];
        f0 = f0 * f1;
        f4 = f4 * f5;
        f8 = heapClassInst.heapFloat[r2 + numDefine24];
        f9 = heapClassInst.heapFloat[r3 + numDefine2];
        f10 = heapClassInst.heapFloat[r2 + numDefine20];
        f11 = heapClassInst.heapFloat[r2 + numDefine16];
        f2 = f2 * f1;
        f6 = f6 * f5;
        f1 = f3 * f1;
        f3 = f7 * f5;
        f0 = f0 + f4;
        f4 = f8 * f9;
        f2 = f2 + f6;
        f5 = f10 * f9;
        f1 = f1 + f3;
        f3 = f11 * f9;
        f0 = f0 + f4;
        f4 = heapClassInst.heapFloat[r2 + numDefine28];
        f2 = f2 + f5;
        f5 = heapClassInst.heapFloat[r2 + numDefine27];
        f1 = f1 + f3;
        f3 = heapClassInst.heapFloat[r2 + numDefine26];
        r3 = heapClassInst.heap32[r2 + numDefine30];
        f0 = f0 + f4;
        f2 = f2 + f5;
        f1 = f1 + f3;
        r4 = heapClassInst.heap32[r2];
        r2 = heapClassInst.heap32[r2 + numDefine31];
        r5 = r3 & 1;
        if (r5 != 0) {
            r5 = (r4 + r2) | 0;
            r5 = r5 >> numDefine2;
            r5 = heapClassInst.heap32[r5];
            r3 = (r3 + r5) | 0;
            r3 = (r3 + -1) | 0;
            r3 = r3 >> numDefine2;
            r3 = heapClassInst.heap32[r3];
        }
        r5 = sp + numDefineNeg48;
        r2 = (r4 + r2) | 0;
        heapClassInst.heap32[g0] = r5;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heap32[g0 + numDefine2] = r1;
        functionTable.get(r3 >> numDefine2).accept(i7);
        r1 = r5 >> numDefine2;
        f3 = heapClassInst.heapFloat[fp + numDefineNeg12];
        f4 = heapClassInst.heapFloat[r1 + numDefine2];
        f5 = heapClassInst.heapFloat[r1 + 1];
        f1 = f3 - f1;
        f2 = f5 - f2;
        heapClassInst.heapFloat[r0 + numDefine4] = f1;
        f0 = f4 - f0;
        heapClassInst.heapFloat[r0 + numDefine5] = f2;
        heapClassInst.heapFloat[r0 + numDefine6] = f0;
        heapClassInst.heap32[r0 + numDefine7] = 0;
        return;
    }

    public static void zn12gjkepa2Impl3GJK13EncloseOriginEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg128;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine93];
        r3 = r2 >> numDefine2;
        r4 = heapClassInst.heap32[r3 + numDefine8];
        repeat1: do {
            if (r4 > numDefine2) {
                if (r4 == numDefine3) {
                    r5 = heapClassInst.heap32[r3];
                    r6 = heapClassInst.heap32[r3 + numDefine2];
                    r7 = heapClassInst.heap32[r3 + 1];
                    r6 = r6 >> numDefine2;
                    r5 = r5 >> numDefine2;
                    r7 = r7 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r6 + numDefine6];
                    f1 = heapClassInst.heapFloat[r5 + numDefine6];
                    f2 = heapClassInst.heapFloat[r7 + numDefine6];
                    f3 = heapClassInst.heapFloat[r6 + numDefine5];
                    f4 = heapClassInst.heapFloat[r5 + numDefine5];
                    f5 = heapClassInst.heapFloat[r7 + numDefine5];
                    f5 = f5 - f4;
                    f0 = f0 - f1;
                    f1 = f2 - f1;
                    f2 = f3 - f4;
                    f3 = heapClassInst.heapFloat[r6 + numDefine4];
                    f4 = heapClassInst.heapFloat[r5 + numDefine4];
                    f6 = heapClassInst.heapFloat[r7 + numDefine4];
                    f3 = f3 - f4;
                    f4 = f6 - f4;
                    f6 = f5 * f0;
                    f7 = f1 * f2;
                    r5 = sp + numDefineNeg112;
                    f6 = f6 - f7;
                    f1 = f1 * f3;
                    f0 = f4 * f0;
                    f0 = f1 - f0;
                    r6 = r5 >> numDefine2;
                    heapClassInst.heapFloat[fp + numDefineNeg28] = f6;
                    f1 = f4 * f2;
                    f2 = f5 * f3;
                    f1 = f1 - f2;
                    heapClassInst.heapFloat[r6 + 1] = f0;
                    f2 = f6 * f6;
                    f0 = f0 * f0;
                    heapClassInst.heapFloat[r6 + numDefine2] = f1;
                    f0 = f2 + f0;
                    f1 = f1 * f1;
                    f0 = f0 + f1;
                    f1 = 0;
                    heapClassInst.heap32[r6 + numDefine3] = 0;
                    if (f0 <= f1) {
                        label = numDefine24;
                        break repeat1;
                    } else {
                        r4 = r4 << numDefine2;
                        r4 = (r2 + r4) | 0;
                        r4 = r4 >> numDefine2;
                        heapClassInst.heap32[r4 + numDefine4] = 0;
                        r4 = heapClassInst.heap32[r1 + numDefine91];
                        r4 = (r4 + -1) | 0;
                        r7 = heapClassInst.heap32[r3 + numDefine8];
                        r8 = r4 << numDefine2;
                        r7 = r7 << numDefine2;
                        r8 = (r0 + r8) | 0;
                        r7 = (r2 + r7) | 0;
                        r8 = r8 >> numDefine2;
                        heapClassInst.heap32[r1 + numDefine91] = r4;
                        r4 = r7 >> numDefine2;
                        r7 = heapClassInst.heap32[r8 + numDefine87];
                        heapClassInst.heap32[r4] = r7;
                        r4 = heapClassInst.heap32[r3 + numDefine8];
                        r7 = r4 << numDefine2;
                        r2 = (r2 + r7) | 0;
                        r2 = r2 >> numDefine2;
                        r2 = heapClassInst.heap32[r2];
                        r4 = (r4 + 1) | 0;
                        heapClassInst.heap32[r3 + numDefine8] = r4;
                        heapClassInst.heap32[g0] = r0;
                        heapClassInst.heap32[g0 + 1] = r5;
                        heapClassInst.heap32[g0 + numDefine2] = r2;
                        znk12gjkepa2Impl3GJK10getsupportERK9btVector3RNS03sSVE(i7);
                        heapClassInst.heap32[g0] = r0;
                        zn12gjkepa2Impl3GJK13EncloseOriginEv(i7);
                        r3 = commonVariable.rg0;
                        if (r3 != 0) {
                            label = numDefine25;
                            break repeat1;
                        } else {
                            r3 = heapClassInst.heap32[r1 + numDefine93];
                            r2 = r3 >> numDefine2;
                            r4 = heapClassInst.heap32[r2 + numDefine8];
                            r4 = (r4 + -1) | 0;
                            r5 = heapClassInst.heap32[r1 + numDefine91];
                            r7 = r4 << numDefine2;
                            r3 = (r3 + r7) | 0;
                            r7 = (r0 + numDefine348) | 0;
                            r8 = r5 << numDefine2;
                            r8 = (r7 + r8) | 0;
                            r3 = r3 >> numDefine2;
                            heapClassInst.heap32[r2 + numDefine8] = r4;
                            r2 = r8 >> numDefine2;
                            r3 = heapClassInst.heap32[r3];
                            r4 = (r5 + 1) | 0;
                            heapClassInst.heap32[r2] = r3;
                            heapClassInst.heap32[r1 + numDefine91] = r4;
                            f0 = heapClassInst.heapFloat[r6 + numDefine2];
                            f1 = heapClassInst.heapFloat[r6 + 1];
                            f2 = heapClassInst.heapFloat[fp + numDefineNeg28];
                            r3 = sp + numDefineNeg16;
                            f2 = -f2;
                            r2 = r3 >> numDefine2;
                            f1 = -f1;
                            heapClassInst.heapFloat[fp + numDefineNeg4] = f2;
                            f0 = -f0;
                            heapClassInst.heapFloat[r2 + 1] = f1;
                            heapClassInst.heapFloat[r2 + numDefine2] = f0;
                            heapClassInst.heap32[r2 + numDefine3] = 0;
                            r2 = heapClassInst.heap32[r1 + numDefine93];
                            r4 = r2 >> numDefine2;
                            r5 = heapClassInst.heap32[r4 + numDefine8];
                            r5 = r5 << numDefine2;
                            r5 = (r2 + r5) | 0;
                            r5 = r5 >> numDefine2;
                            heapClassInst.heap32[r5 + numDefine4] = 0;
                            r5 = heapClassInst.heap32[r1 + numDefine91];
                            r5 = (r5 + -1) | 0;
                            r6 = heapClassInst.heap32[r4 + numDefine8];
                            r8 = r5 << numDefine2;
                            r6 = r6 << numDefine2;
                            r7 = (r7 + r8) | 0;
                            r6 = (r2 + r6) | 0;
                            r7 = r7 >> numDefine2;
                            heapClassInst.heap32[r1 + numDefine91] = r5;
                            r5 = r6 >> numDefine2;
                            r6 = heapClassInst.heap32[r7];
                            heapClassInst.heap32[r5] = r6;
                            r5 = heapClassInst.heap32[r4 + numDefine8];
                            r6 = r5 << numDefine2;
                            r2 = (r2 + r6) | 0;
                            r2 = r2 >> numDefine2;
                            r2 = heapClassInst.heap32[r2];
                            r5 = (r5 + 1) | 0;
                            heapClassInst.heap32[r4 + numDefine8] = r5;
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r3;
                            heapClassInst.heap32[g0 + numDefine2] = r2;
                            znk12gjkepa2Impl3GJK10getsupportERK9btVector3RNS03sSVE(i7);
                            heapClassInst.heap32[g0] = r0;
                            zn12gjkepa2Impl3GJK13EncloseOriginEv(i7);
                            r3 = commonVariable.rg0;
                            if (r3 != 0) {
                                label = numDefine25;
                                break repeat1;
                            } else {
                                r3 = heapClassInst.heap32[r1 + numDefine93];
                                r2 = r3 >> numDefine2;
                                r4 = heapClassInst.heap32[r2 + numDefine8];
                                r4 = (r4 + -1) | 0;
                                r5 = heapClassInst.heap32[r1 + numDefine91];
                                r6 = r4 << numDefine2;
                                r7 = r5 << numDefine2;
                                r3 = (r3 + r6) | 0;
                                r0 = (r0 + r7) | 0;
                                r3 = r3 >> numDefine2;
                                heapClassInst.heap32[r2 + numDefine8] = r4;
                                r0 = r0 >> numDefine2;
                                r3 = heapClassInst.heap32[r3];
                                r2 = (r5 + 1) | 0;
                                heapClassInst.heap32[r0 + numDefine87] = r3;
                                heapClassInst.heap32[r1 + numDefine91] = r2;
                                r3 = 0;
                                commonVariable.rg0 = r3;
                                return;
                            }
                        }
                    }
                } else {
                    if (r4 == numDefine4) {
                        r0 = heapClassInst.heap32[r3];
                        r1 = heapClassInst.heap32[r3 + 1];
                        r2 = heapClassInst.heap32[r3 + numDefine3];
                        r0 = r0 >> numDefine2;
                        r1 = r1 >> numDefine2;
                        r2 = r2 >> numDefine2;
                        r3 = heapClassInst.heap32[r3 + numDefine2];
                        r3 = r3 >> numDefine2;
                        f0 = heapClassInst.heapFloat[r1 + numDefine6];
                        f1 = heapClassInst.heapFloat[r2 + numDefine6];
                        f2 = heapClassInst.heapFloat[r0 + numDefine6];
                        f3 = heapClassInst.heapFloat[r0 + numDefine5];
                        f4 = heapClassInst.heapFloat[r2 + numDefine5];
                        f5 = heapClassInst.heapFloat[r1 + numDefine4];
                        f6 = heapClassInst.heapFloat[r2 + numDefine4];
                        f7 = heapClassInst.heapFloat[r3 + numDefine5];
                        f8 = heapClassInst.heapFloat[r0 + numDefine4];
                        f9 = heapClassInst.heapFloat[r3 + numDefine4];
                        f0 = f0 - f1;
                        f3 = f3 - f4;
                        f5 = f5 - f6;
                        f2 = f2 - f1;
                        f8 = f8 - f6;
                        f10 = f3 * f0;
                        f6 = f9 - f6;
                        f9 = f2 * f5;
                        f7 = f7 - f4;
                        f0 = f8 * f0;
                        f11 = heapClassInst.heapFloat[r3 + numDefine6];
                        f12 = heapClassInst.heapFloat[r1 + numDefine5];
                        f10 = f10 * f6;
                        f9 = f9 * f7;
                        f4 = f12 - f4;
                        f9 = f10 + f9;
                        f0 = f0 * f7;
                        f3 = f3 * f5;
                        f1 = f11 - f1;
                        f5 = f8 * f4;
                        f0 = f9 - f0;
                        f3 = f3 * f1;
                        f2 = f2 * f4;
                        f0 = f0 - f3;
                        f1 = f5 * f1;
                        f0 = f0 + f1;
                        f1 = f2 * f6;
                        f0 = f0 - f1;
                        f1 = 0;
                        if (f0 < f1) {
                            f0 = -f0;
                        }

                        r0 = f0 > f1 ? 1 : 0;
                        r0 = r0 & 1;
                        commonVariable.rg0 = r0;
                        return;
                    } else {
                        label = numDefine24;
                        break repeat1;
                    }
                }
            } else {
                if (r4 == 1) {
                    r2 = 0;
                    repeat16: while (true) {
                        if (uint(r2) < uint(numDefine3)) {
                            r3 = sp + numDefineNeg64;
                            r4 = r3 >> numDefine2;
                            heapClassInst.heap32[fp + numDefineNeg16] = 0;
                            r5 = r2 << numDefine2;
                            heapClassInst.heap32[r4 + 1] = 0;
                            r5 = (r3 + r5) | 0;
                            heapClassInst.heap32[r4 + numDefine2] = 0;
                            r5 = r5 >> numDefine2;
                            heapClassInst.heap32[r4 + numDefine3] = 0;
                            heapClassInst.heap32[r5] = numDefine53216;
                            r5 = heapClassInst.heap32[r1 + numDefine93];
                            r6 = r5 >> numDefine2;
                            r7 = heapClassInst.heap32[r6 + numDefine8];
                            r7 = r7 << numDefine2;
                            r7 = (r5 + r7) | 0;
                            r7 = r7 >> numDefine2;
                            heapClassInst.heap32[r7 + numDefine4] = 0;
                            r7 = heapClassInst.heap32[r1 + numDefine91];
                            r7 = (r7 + -1) | 0;
                            r8 = heapClassInst.heap32[r6 + numDefine8];
                            r9 = r7 << numDefine2;
                            r8 = r8 << numDefine2;
                            r9 = (r0 + r9) | 0;
                            r8 = (r5 + r8) | 0;
                            r9 = r9 >> numDefine2;
                            heapClassInst.heap32[r1 + numDefine91] = r7;
                            r7 = r8 >> numDefine2;
                            r8 = heapClassInst.heap32[r9 + numDefine87];
                            heapClassInst.heap32[r7] = r8;
                            r7 = heapClassInst.heap32[r6 + numDefine8];
                            r8 = r7 << numDefine2;
                            r5 = (r5 + r8) | 0;
                            r5 = r5 >> numDefine2;
                            r5 = heapClassInst.heap32[r5];
                            r7 = (r7 + 1) | 0;
                            heapClassInst.heap32[r6 + numDefine8] = r7;
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r3;
                            heapClassInst.heap32[g0 + numDefine2] = r5;
                            znk12gjkepa2Impl3GJK10getsupportERK9btVector3RNS03sSVE(i7);
                            heapClassInst.heap32[g0] = r0;
                            zn12gjkepa2Impl3GJK13EncloseOriginEv(i7);
                            r3 = commonVariable.rg0;
                            if (r3 != 0) {
                                label = numDefine25;
                                break repeat1;
                            } else {
                                r3 = heapClassInst.heap32[r1 + numDefine93];
                                r5 = r3 >> numDefine2;
                                r6 = heapClassInst.heap32[r5 + numDefine8];
                                r6 = (r6 + -1) | 0;
                                r7 = heapClassInst.heap32[r1 + numDefine91];
                                r8 = r6 << numDefine2;
                                r3 = (r3 + r8) | 0;
                                r8 = (r0 + numDefine348) | 0;
                                r9 = r7 << numDefine2;
                                r9 = (r8 + r9) | 0;
                                r3 = r3 >> numDefine2;
                                heapClassInst.heap32[r5 + numDefine8] = r6;
                                r5 = r9 >> numDefine2;
                                r3 = heapClassInst.heap32[r3];
                                r6 = (r7 + 1) | 0;
                                heapClassInst.heap32[r5] = r3;
                                heapClassInst.heap32[r1 + numDefine91] = r6;
                                f0 = heapClassInst.heapFloat[r4 + numDefine2];
                                f1 = heapClassInst.heapFloat[r4 + 1];
                                f2 = heapClassInst.heapFloat[fp + numDefineNeg16];
                                r3 = sp + numDefineNeg48;
                                f2 = -f2;
                                r4 = r3 >> numDefine2;
                                f1 = -f1;
                                heapClassInst.heapFloat[fp + numDefineNeg12] = f2;
                                f0 = -f0;
                                heapClassInst.heapFloat[r4 + 1] = f1;
                                heapClassInst.heapFloat[r4 + numDefine2] = f0;
                                heapClassInst.heap32[r4 + numDefine3] = 0;
                                r4 = heapClassInst.heap32[r1 + numDefine93];
                                r5 = r4 >> numDefine2;
                                r6 = heapClassInst.heap32[r5 + numDefine8];
                                r6 = r6 << numDefine2;
                                r6 = (r4 + r6) | 0;
                                r6 = r6 >> numDefine2;
                                heapClassInst.heap32[r6 + numDefine4] = 0;
                                r6 = heapClassInst.heap32[r1 + numDefine91];
                                r6 = (r6 + -1) | 0;
                                r7 = heapClassInst.heap32[r5 + numDefine8];
                                r9 = r6 << numDefine2;
                                r7 = r7 << numDefine2;
                                r8 = (r8 + r9) | 0;
                                r7 = (r4 + r7) | 0;
                                r8 = r8 >> numDefine2;
                                heapClassInst.heap32[r1 + numDefine91] = r6;
                                r6 = r7 >> numDefine2;
                                r7 = heapClassInst.heap32[r8];
                                heapClassInst.heap32[r6] = r7;
                                r6 = heapClassInst.heap32[r5 + numDefine8];
                                r7 = r6 << numDefine2;
                                r4 = (r4 + r7) | 0;
                                r4 = r4 >> numDefine2;
                                r4 = heapClassInst.heap32[r4];
                                r6 = (r6 + 1) | 0;
                                heapClassInst.heap32[r5 + numDefine8] = r6;
                                heapClassInst.heap32[g0] = r0;
                                heapClassInst.heap32[g0 + 1] = r3;
                                heapClassInst.heap32[g0 + numDefine2] = r4;
                                znk12gjkepa2Impl3GJK10getsupportERK9btVector3RNS03sSVE(i7);
                                heapClassInst.heap32[g0] = r0;
                                zn12gjkepa2Impl3GJK13EncloseOriginEv(i7);
                                r3 = commonVariable.rg0;
                                if (r3 != 0) {
                                    label = numDefine25;
                                    break repeat1;
                                } else {
                                    r3 = heapClassInst.heap32[r1 + numDefine93];
                                    r4 = r3 >> numDefine2;
                                    r5 = heapClassInst.heap32[r4 + numDefine8];
                                    r5 = (r5 + -1) | 0;
                                    r6 = heapClassInst.heap32[r1 + numDefine91];
                                    r7 = r5 << numDefine2;
                                    r8 = r6 << numDefine2;
                                    r3 = (r3 + r7) | 0;
                                    r7 = (r0 + r8) | 0;
                                    r3 = r3 >> numDefine2;
                                    heapClassInst.heap32[r4 + numDefine8] = r5;
                                    r4 = r7 >> numDefine2;
                                    r3 = heapClassInst.heap32[r3];
                                    r2 = (r2 + 1) | 0;
                                    r5 = (r6 + 1) | 0;
                                    heapClassInst.heap32[r4 + numDefine87] = r3;
                                    heapClassInst.heap32[r1 + numDefine91] = r5;
                                    continue repeat16;
                                }
                            }
                        } else {
                            label = numDefine24;
                            break repeat1;
                        }
                    }
                } else {
                    if (r4 == numDefine2) {
                        r2 = heapClassInst.heap32[r3 + 1];
                        r3 = heapClassInst.heap32[r3];
                        r2 = r2 >> numDefine2;
                        r3 = r3 >> numDefine2;
                        f0 = heapClassInst.heapFloat[r2 + numDefine6];
                        f1 = heapClassInst.heapFloat[r3 + numDefine6];
                        f2 = heapClassInst.heapFloat[r2 + numDefine5];
                        f3 = heapClassInst.heapFloat[r3 + numDefine5];
                        f4 = heapClassInst.heapFloat[r2 + numDefine4];
                        f5 = heapClassInst.heapFloat[r3 + numDefine4];
                        f0 = f0 - f1;
                        f1 = f2 - f3;
                        f2 = f4 - f5;
                        r2 = 0;
                        repeat23: while (true) {
                            if (uint(r2) < uint(numDefine3)) {
                                r3 = sp + numDefineNeg80;
                                r4 = r3 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg20] = 0;
                                r5 = r2 << numDefine2;
                                heapClassInst.heap32[r4 + 1] = 0;
                                r3 = (r3 + r5) | 0;
                                heapClassInst.heap32[r4 + numDefine2] = 0;
                                r3 = r3 >> numDefine2;
                                heapClassInst.heap32[r4 + numDefine3] = 0;
                                heapClassInst.heap32[r3] = numDefine53216;
                                f3 = heapClassInst.heapFloat[r4 + numDefine2];
                                f4 = heapClassInst.heapFloat[r4 + 1];
                                f5 = heapClassInst.heapFloat[fp + numDefineNeg20];
                                f6 = f1 * f3;
                                f7 = f0 * f4;
                                r3 = sp + numDefineNeg96;
                                f6 = f6 - f7;
                                f7 = f0 * f5;
                                f3 = f2 * f3;
                                f3 = f7 - f3;
                                r4 = r3 >> numDefine2;
                                heapClassInst.heapFloat[fp + numDefineNeg24] = f6;
                                f4 = f2 * f4;
                                f5 = f1 * f5;
                                f4 = f4 - f5;
                                heapClassInst.heapFloat[r4 + 1] = f3;
                                f5 = f6 * f6;
                                f3 = f3 * f3;
                                heapClassInst.heapFloat[r4 + numDefine2] = f4;
                                f3 = f5 + f3;
                                f4 = f4 * f4;
                                f3 = f3 + f4;
                                f4 = 0;
                                heapClassInst.heap32[r4 + numDefine3] = 0;
                                if (!(f3 <= f4)) {
                                    r5 = heapClassInst.heap32[r1 + numDefine93];
                                    r6 = r5 >> numDefine2;
                                    r7 = heapClassInst.heap32[r6 + numDefine8];
                                    r7 = r7 << numDefine2;
                                    r7 = (r5 + r7) | 0;
                                    r7 = r7 >> numDefine2;
                                    heapClassInst.heap32[r7 + numDefine4] = 0;
                                    r7 = heapClassInst.heap32[r1 + numDefine91];
                                    r7 = (r7 + -1) | 0;
                                    r8 = heapClassInst.heap32[r6 + numDefine8];
                                    r9 = r7 << numDefine2;
                                    r8 = r8 << numDefine2;
                                    r9 = (r0 + r9) | 0;
                                    r8 = (r5 + r8) | 0;
                                    r9 = r9 >> numDefine2;
                                    heapClassInst.heap32[r1 + numDefine91] = r7;
                                    r7 = r8 >> numDefine2;
                                    r8 = heapClassInst.heap32[r9 + numDefine87];
                                    heapClassInst.heap32[r7] = r8;
                                    r7 = heapClassInst.heap32[r6 + numDefine8];
                                    r8 = r7 << numDefine2;
                                    r5 = (r5 + r8) | 0;
                                    r5 = r5 >> numDefine2;
                                    r5 = heapClassInst.heap32[r5];
                                    r7 = (r7 + 1) | 0;
                                    heapClassInst.heap32[r6 + numDefine8] = r7;
                                    heapClassInst.heap32[g0] = r0;
                                    heapClassInst.heap32[g0 + 1] = r3;
                                    heapClassInst.heap32[g0 + numDefine2] = r5;
                                    znk12gjkepa2Impl3GJK10getsupportERK9btVector3RNS03sSVE(i7);
                                    heapClassInst.heap32[g0] = r0;
                                    zn12gjkepa2Impl3GJK13EncloseOriginEv(i7);
                                    r3 = commonVariable.rg0;
                                    if (r3 != 0) {
                                        label = numDefine25;
                                        break repeat1;
                                    } else {
                                        r3 = heapClassInst.heap32[r1 + numDefine93];
                                        r5 = r3 >> numDefine2;
                                        r6 = heapClassInst.heap32[r5 + numDefine8];
                                        r6 = (r6 + -1) | 0;
                                        r7 = heapClassInst.heap32[r1 + numDefine91];
                                        r8 = r6 << numDefine2;
                                        r3 = (r3 + r8) | 0;
                                        r8 = (r0 + numDefine348) | 0;
                                        r9 = r7 << numDefine2;
                                        r9 = (r8 + r9) | 0;
                                        r3 = r3 >> numDefine2;
                                        heapClassInst.heap32[r5 + numDefine8] = r6;
                                        r5 = r9 >> numDefine2;
                                        r3 = heapClassInst.heap32[r3];
                                        r6 = (r7 + 1) | 0;
                                        heapClassInst.heap32[r5] = r3;
                                        heapClassInst.heap32[r1 + numDefine91] = r6;
                                        f3 = heapClassInst.heapFloat[r4 + numDefine2];
                                        f4 = heapClassInst.heapFloat[r4 + 1];
                                        f5 = heapClassInst.heapFloat[fp + numDefineNeg24];
                                        r3 = sp + numDefineNeg32;
                                        f5 = -f5;
                                        r4 = r3 >> numDefine2;
                                        f4 = -f4;
                                        heapClassInst.heapFloat[fp + numDefineNeg8] = f5;
                                        f3 = -f3;
                                        heapClassInst.heapFloat[r4 + 1] = f4;
                                        heapClassInst.heapFloat[r4 + numDefine2] = f3;
                                        heapClassInst.heap32[r4 + numDefine3] = 0;
                                        r4 = heapClassInst.heap32[r1 + numDefine93];
                                        r5 = r4 >> numDefine2;
                                        r6 = heapClassInst.heap32[r5 + numDefine8];
                                        r6 = r6 << numDefine2;
                                        r6 = (r4 + r6) | 0;
                                        r6 = r6 >> numDefine2;
                                        heapClassInst.heap32[r6 + numDefine4] = 0;
                                        r6 = heapClassInst.heap32[r1 + numDefine91];
                                        r6 = (r6 + -1) | 0;
                                        r7 = heapClassInst.heap32[r5 + numDefine8];
                                        r9 = r6 << numDefine2;
                                        r7 = r7 << numDefine2;
                                        r8 = (r8 + r9) | 0;
                                        r7 = (r4 + r7) | 0;
                                        r8 = r8 >> numDefine2;
                                        heapClassInst.heap32[r1 + numDefine91] = r6;
                                        r6 = r7 >> numDefine2;
                                        r7 = heapClassInst.heap32[r8];
                                        heapClassInst.heap32[r6] = r7;
                                        r6 = heapClassInst.heap32[r5 + numDefine8];
                                        r7 = r6 << numDefine2;
                                        r4 = (r4 + r7) | 0;
                                        r4 = r4 >> numDefine2;
                                        r4 = heapClassInst.heap32[r4];
                                        r6 = (r6 + 1) | 0;
                                        heapClassInst.heap32[r5 + numDefine8] = r6;
                                        heapClassInst.heap32[g0] = r0;
                                        heapClassInst.heap32[g0 + 1] = r3;
                                        heapClassInst.heap32[g0 + numDefine2] = r4;
                                        znk12gjkepa2Impl3GJK10getsupportERK9btVector3RNS03sSVE(i7);
                                        heapClassInst.heap32[g0] = r0;
                                        zn12gjkepa2Impl3GJK13EncloseOriginEv(i7);
                                        r3 = commonVariable.rg0;
                                        if (r3 != 0) {
                                            label = numDefine25;
                                            break repeat1;
                                        } else {
                                            r3 = heapClassInst.heap32[r1 + numDefine93];
                                            r4 = r3 >> numDefine2;
                                            r5 = heapClassInst.heap32[r4 + numDefine8];
                                            r5 = (r5 + -1) | 0;
                                            r6 = heapClassInst.heap32[r1 + numDefine91];
                                            r7 = r5 << numDefine2;
                                            r8 = r6 << numDefine2;
                                            r3 = (r3 + r7) | 0;
                                            r7 = (r0 + r8) | 0;
                                            r3 = r3 >> numDefine2;
                                            heapClassInst.heap32[r4 + numDefine8] = r5;
                                            r4 = r7 >> numDefine2;
                                            r3 = heapClassInst.heap32[r3];
                                            r5 = (r6 + 1) | 0;
                                            heapClassInst.heap32[r4 + numDefine87] = r3;
                                            heapClassInst.heap32[r1 + numDefine91] = r5;
                                        }
                                    }
                                }
                                r2 = (r2 + 1) | 0;
                                continue repeat23;
                            } else {
                                label = numDefine24;
                                break repeat1;
                            }
                        }
                    } else {
                        label = numDefine24;
                    }
                }
            }
        } while (false);
        switch (label) {
            case numDefine24:
                r0 = 0;
                commonVariable.rg0 = r0;
                return;
            case numDefine25:
                r0 = 1;
                commonVariable.rg0 = r0;
                return;
            default:
                break;
        }
    }

    public static void zn12gjkepa2Impl3GJK13projectoriginERK9btVector3S3S3PfRj(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg96;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = sp + numDefineNeg12;
        r2 = heapClassInst.heap32[fp + 1];
        r3 = r1 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg3] = r0;
        r4 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[r3 + 1] = r2;
        r5 = r0 >> numDefine2;
        heapClassInst.heap32[r3 + numDefine2] = r4;
        r2 = r2 >> numDefine2;
        f0 = heapClassInst.heapFloat[r5 + numDefine2];
        f1 = heapClassInst.heapFloat[r2 + numDefine2];
        f2 = heapClassInst.heapFloat[r5 + 1];
        f3 = heapClassInst.heapFloat[r2 + 1];
        f4 = heapClassInst.heapFloat[r5];
        f5 = heapClassInst.heapFloat[r2];
        r3 = sp + numDefineNeg64;
        f6 = f4 - f5;
        f7 = f2 - f3;
        r6 = r3 >> numDefine2;
        heapClassInst.heapFloat[fp + numDefineNeg16] = f6;
        f8 = f0 - f1;
        heapClassInst.heapFloat[r6 + 1] = f7;
        heapClassInst.heapFloat[r6 + numDefine2] = f8;
        r4 = r4 >> numDefine2;
        heapClassInst.heap32[r6 + numDefine3] = 0;
        f9 = heapClassInst.heapFloat[r4 + numDefine2];
        f10 = heapClassInst.heapFloat[r4 + 1];
        f11 = heapClassInst.heapFloat[r4];
        f5 = f5 - f11;
        f3 = f3 - f10;
        heapClassInst.heapFloat[r6 + numDefine4] = f5;
        f1 = f1 - f9;
        heapClassInst.heapFloat[r6 + numDefine5] = f3;
        heapClassInst.heapFloat[r6 + numDefine6] = f1;
        f12 = f8 * f5;
        f13 = f6 * f1;
        f14 = f7 * f1;
        f15 = f8 * f3;
        f12 = f12 - f13;
        f13 = f14 - f15;
        f11 = f11 - f4;
        heapClassInst.heap32[r6 + numDefine7] = 0;
        f14 = f6 * f3;
        f15 = f7 * f5;
        f14 = f14 - f15;
        f10 = f10 - f2;
        heapClassInst.heapFloat[r6 + numDefine8] = f11;
        f15 = f13 * f13;
        f16 = f12 * f12;
        f9 = f9 - f0;
        heapClassInst.heapFloat[r6 + numDefine9] = f10;
        f15 = f15 + f16;
        f16 = f14 * f14;
        f15 = f15 + f16;
        heapClassInst.heapFloat[r6 + numDefine10] = f9;
        heapClassInst.heap32[r6 + numDefine11] = 0;
        f16 = 0;
        if (f15 > f16) {
            r6 = heapClassInst.heap32[fp + numDefine3];
            r7 = heapClassInst.heap32[fp + numDefine4];
            r8 = sp + numDefineNeg72;
            r9 = r8 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg18] = 0;
            r10 = 0;
            f17 = -1;
            heapClassInst.heap32[r9 + 1] = 0;
            heapClassInst.heap32[fp + numDefineNeg19] = 0;
            r18 = 0;
            repeat3: while (true) {
                f18 = f7 * f14;
                f19 = f8 * f12;
                f8 = f8 * f13;
                f20 = f6 * f14;
                f18 = f18 - f19;
                f8 = f8 - f20;
                f6 = f6 * f12;
                f7 = f7 * f13;
                f4 = f4 * f18;
                f2 = f2 * f8;
                f6 = f6 - f7;
                f2 = f4 + f2;
                f0 = f0 * f6;
                f0 = f2 + f0;
                repeat5: do {
                    if (f0 > f16) {
                        r11 = zzn12gjkepa2Impl3GJK13projectoriginERK9btVector3S3S3PfRjE4imd3;
                        r12 = r10 << numDefine2;
                        r13 = (r11 + r12) | 0;
                        r13 = r13 >> numDefine2;
                        r13 = heapClassInst.heap32[r13];
                        r14 = r13 << numDefine2;
                        r15 = (r1 + r14) | 0;
                        r15 = r15 >> numDefine2;
                        r15 = heapClassInst.heap32[r15];
                        r16 = sp + numDefineNeg76;
                        heapClassInst.heap32[g0] = r0;
                        heapClassInst.heap32[g0 + 1] = r15;
                        heapClassInst.heap32[g0 + numDefine2] = r8;
                        heapClassInst.heap32[g0 + numDefine3] = r16;
                        zn12gjkepa2Impl3GJK13projectoriginERK9btVector3S3PfRj(i7);
                        f0 = (float) commonVariable.fg0;
                        if (!(f17 < f16)) {
                            if (f0 >= f17) {
                                break repeat5;
                            }
                        }
                        r0 = heapClassInst.heap32[fp + numDefineNeg19];
                        r15 = 1;
                        r11 = (r11 + r14) | 0;
                        r16 = r0 & 1;
                        r17 = r15 << r10;
                        r0 = r0 & numDefine2;
                        r13 = r15 << r13;
                        r11 = r11 >> numDefine2;
                        r15 = r16 == 0 ? r18 : r17;
                        r0 = r0 == 0 ? r18 : r13;
                        r11 = heapClassInst.heap32[r11];
                        r12 = (r6 + r12) | 0;
                        r13 = r7 >> numDefine2;
                        r0 = (r15 + r0) | 0;
                        r11 = r11 << numDefine2;
                        r14 = (r6 + r14) | 0;
                        r12 = r12 >> numDefine2;
                        heapClassInst.heap32[r13] = r0;
                        r0 = (r6 + r11) | 0;
                        r11 = r14 >> numDefine2;
                        heapClassInst.heap32[r12] = heapClassInst.heap32[fp + numDefineNeg18];
                        r0 = r0 >> numDefine2;
                        heapClassInst.heap32[r11] = heapClassInst.heap32[r9 + 1];
                        heapClassInst.heap32[r0] = 0;
                        f17 = f0;
                    }
                } while (false);
                if (r10 == numDefine2) {
                    break repeat3;
                } else {
                    r11 = (r10 + 1) | 0;
                    r0 = r10 << numDefine2;
                    r0 = (r1 + r0) | 0;
                    r0 = r0 >> numDefine2;
                    r10 = r10 << numDefine4;
                    r0 = heapClassInst.heap32[r0 + 1];
                    r10 = (r3 + r10) | 0;
                    r10 = r10 >> numDefine2;
                    r12 = r0 >> numDefine2;
                    f6 = heapClassInst.heapFloat[r10 + numDefine4];
                    f7 = heapClassInst.heapFloat[r10 + numDefine5];
                    f8 = heapClassInst.heapFloat[r10 + numDefine6];
                    f4 = heapClassInst.heapFloat[r12];
                    f2 = heapClassInst.heapFloat[r12 + 1];
                    f0 = heapClassInst.heapFloat[r12 + numDefine2];
                    r10 = r11;
                }
            }
            if (f17 < f16) {
                f17 = heapClassInst.heapFloat[r5];
                f0 = heapClassInst.heapFloat[r5 + 1];
                f2 = heapClassInst.heapFloat[r5 + numDefine2];
                f17 = f17 * f13;
                f0 = f0 * f12;
                heapClassInst.heapFloat[g0] = f15;
                f17 = f17 + f0;
                f0 = f2 * f14;
                f17 = f17 + f0;
                r0 = r7 >> numDefine2;
                sqrtf(i7);
                f0 = (float) commonVariable.fg0;
                f17 = f17 / f15;
                heapClassInst.heap32[r0] = numDefine7;
                f2 = f13 * f17;
                f4 = heapClassInst.heapFloat[r2];
                f6 = f12 * f17;
                f7 = heapClassInst.heapFloat[r2 + 1];
                f8 = heapClassInst.heapFloat[r2 + numDefine2];
                f17 = f14 * f17;
                f7 = f7 - f6;
                f8 = f8 - f17;
                f4 = f4 - f2;
                f12 = f3 * f8;
                f13 = f1 * f7;
                f1 = f1 * f4;
                f8 = f5 * f8;
                f12 = f12 - f13;
                f1 = f1 - f8;
                f5 = f5 * f7;
                f3 = f3 * f4;
                f3 = f5 - f3;
                f4 = f12 * f12;
                f1 = f1 * f1;
                f1 = f4 + f1;
                f3 = f3 * f3;
                f1 = f1 + f3;
                heapClassInst.heapFloat[g0] = f1;
                sqrtf(i7);
                r0 = r6 >> numDefine2;
                f1 = (float) (commonVariable.fg0 / f0);
                heapClassInst.heapFloat[r0] = f1;
                f1 = heapClassInst.heapFloat[r4 + numDefine2];
                f3 = heapClassInst.heapFloat[r4 + 1];
                f4 = heapClassInst.heapFloat[r4];
                f3 = f3 - f6;
                f1 = f1 - f17;
                f4 = f4 - f2;
                f5 = f10 * f1;
                f7 = f9 * f3;
                f8 = f9 * f4;
                f1 = f11 * f1;
                f5 = f5 - f7;
                f1 = f8 - f1;
                f3 = f11 * f3;
                f4 = f10 * f4;
                f3 = f3 - f4;
                f4 = f5 * f5;
                f1 = f1 * f1;
                f1 = f4 + f1;
                f3 = f3 * f3;
                f1 = f1 + f3;
                heapClassInst.heapFloat[g0] = f1;
                sqrtf(i7);
                f0 = (float) (commonVariable.fg0 / f0);
                heapClassInst.heapFloat[r0 + 1] = f0;
                f1 = heapClassInst.heapFloat[r0];
                f3 = 1;
                f0 = f1 + f0;
                f1 = f2 * f2;
                f2 = f6 * f6;
                f0 = f3 - f0;
                f1 = f1 + f2;
                f17 = f17 * f17;
                heapClassInst.heapFloat[r0 + numDefine2] = f0;
                f17 = f1 + f17;
            }
        } else {
            f17 = -1;
        }
        commonVariable.fg0 = f17;
        return;
    }

    public static void zn12gjkepa2Impl3GJK8EvaluateERKNS13MinkowskiDiffERK9btVector3(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        int r20 = 0;
        int r21 = 0;
        int r22 = 0;
        int r23 = 0;
        int r24 = 0;
        int r25 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg240;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = (r0 + numDefine220) | 0;
        r3 = (r0 + numDefine252) | 0;
        heapClassInst.heap32[r1 + numDefine87] = r2;
        r2 = (r0 + numDefine284) | 0;
        heapClassInst.heap32[r1 + numDefine88] = r3;
        r3 = (r0 + numDefine316) | 0;
        heapClassInst.heap32[r1 + numDefine89] = r2;
        heapClassInst.heap32[r1 + numDefine90] = r3;
        heapClassInst.heap32[r1 + numDefine91] = numDefine4;
        r2 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[r1 + numDefine92] = 0;
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine94] = 0;
        r4 = heapClassInst.heap32[r2 + 1];
        r5 = heapClassInst.heap32[r2];
        heapClassInst.heap32[r1] = r5;
        heapClassInst.heap32[r1 + 1] = r4;
        heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r2 + numDefine2];
        heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r2 + numDefine3];
        heapClassInst.heap32[r1 + numDefine4] = heapClassInst.heap32[r2 + numDefine4];
        heapClassInst.heap32[r1 + numDefine5] = heapClassInst.heap32[r2 + numDefine5];
        heapClassInst.heap32[r1 + numDefine6] = heapClassInst.heap32[r2 + numDefine6];
        heapClassInst.heap32[r1 + numDefine7] = heapClassInst.heap32[r2 + numDefine7];
        heapClassInst.heap32[r1 + numDefine8] = heapClassInst.heap32[r2 + numDefine8];
        heapClassInst.heap32[r1 + numDefine9] = heapClassInst.heap32[r2 + numDefine9];
        heapClassInst.heap32[r1 + numDefine10] = heapClassInst.heap32[r2 + numDefine10];
        heapClassInst.heap32[r1 + numDefine11] = heapClassInst.heap32[r2 + numDefine11];
        heapClassInst.heap32[r1 + numDefine12] = heapClassInst.heap32[r2 + numDefine12];
        heapClassInst.heap32[r1 + numDefine13] = heapClassInst.heap32[r2 + numDefine13];
        heapClassInst.heap32[r1 + numDefine14] = heapClassInst.heap32[r2 + numDefine14];
        heapClassInst.heap32[r1 + numDefine15] = heapClassInst.heap32[r2 + numDefine15];
        heapClassInst.heap32[r1 + numDefine16] = heapClassInst.heap32[r2 + numDefine16];
        heapClassInst.heap32[r1 + numDefine17] = heapClassInst.heap32[r2 + numDefine17];
        heapClassInst.heap32[r1 + numDefine18] = heapClassInst.heap32[r2 + numDefine18];
        heapClassInst.heap32[r1 + numDefine19] = heapClassInst.heap32[r2 + numDefine19];
        heapClassInst.heap32[r1 + numDefine20] = heapClassInst.heap32[r2 + numDefine20];
        heapClassInst.heap32[r1 + numDefine21] = heapClassInst.heap32[r2 + numDefine21];
        heapClassInst.heap32[r1 + numDefine22] = heapClassInst.heap32[r2 + numDefine22];
        heapClassInst.heap32[r1 + numDefine23] = heapClassInst.heap32[r2 + numDefine23];
        heapClassInst.heap32[r1 + numDefine24] = heapClassInst.heap32[r2 + numDefine24];
        heapClassInst.heap32[r1 + numDefine25] = heapClassInst.heap32[r2 + numDefine25];
        heapClassInst.heap32[r1 + numDefine26] = heapClassInst.heap32[r2 + numDefine26];
        heapClassInst.heap32[r1 + numDefine27] = heapClassInst.heap32[r2 + numDefine27];
        heapClassInst.heap32[r1 + numDefine28] = heapClassInst.heap32[r2 + numDefine28];
        heapClassInst.heap32[r1 + numDefine29] = heapClassInst.heap32[r2 + numDefine29];
        r4 = heapClassInst.heap32[r2 + numDefine31];
        r2 = heapClassInst.heap32[r2 + numDefine30];
        heapClassInst.heap32[r1 + numDefine30] = r2;
        heapClassInst.heap32[r1 + numDefine31] = r4;
        r2 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[r1 + numDefine36] = 0;
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine45] = 0;
        f0 = heapClassInst.heapFloat[r2];
        heapClassInst.heapFloat[r1 + numDefine32] = f0;
        f1 = heapClassInst.heapFloat[r2 + 1];
        heapClassInst.heapFloat[r1 + numDefine33] = f1;
        f2 = heapClassInst.heapFloat[r2 + numDefine2];
        f3 = f0 * f0;
        f4 = f1 * f1;
        f3 = f3 + f4;
        f4 = f2 * f2;
        f3 = f3 + f4;
        heapClassInst.heapFloat[r1 + numDefine34] = f2;
        heapClassInst.heap32[r1 + numDefine35] = heapClassInst.heap32[r2 + numDefine3];
        f4 = 0;
        if (f3 <= f4) {
            r2 = sp + numDefineNeg112;
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg28] = numDefine53216;
            heapClassInst.heap32[r2 + 1] = 0;
            heapClassInst.heap32[r2 + numDefine2] = 0;
            heapClassInst.heap32[r2 + numDefine3] = 0;
        } else {
            r2 = sp + numDefineNeg112;
            f0 = -f0;
            r2 = r2 >> numDefine2;
            f1 = -f1;
            heapClassInst.heapFloat[fp + numDefineNeg28] = f0;
            f0 = -f2;
            heapClassInst.heapFloat[r2 + 1] = f1;
            heapClassInst.heapFloat[r2 + numDefine2] = f0;
            heapClassInst.heap32[r2 + numDefine3] = 0;
        }
        heapClassInst.heap32[r1 + numDefine41] = 0;
        heapClassInst.heap32[r1 + numDefine91] = numDefine3;
        heapClassInst.heap32[r1 + numDefine37] = r3;
        heapClassInst.heap32[r1 + numDefine45] = 1;
        r2 = sp + numDefineNeg112;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r2;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        znk12gjkepa2Impl3GJK10getsupportERK9btVector3RNS03sSVE(i7);
        heapClassInst.heap32[r1 + numDefine41] = numDefine53216;
        r2 = heapClassInst.heap32[r1 + numDefine37];
        r2 = r2 >> numDefine2;
        f0 = heapClassInst.heapFloat[r2 + numDefine4];
        heapClassInst.heapFloat[r1 + numDefine32] = f0;
        f1 = heapClassInst.heapFloat[r2 + numDefine5];
        heapClassInst.heapFloat[r1 + numDefine33] = f1;
        f2 = heapClassInst.heapFloat[r2 + numDefine6];
        heapClassInst.heapFloat[r1 + numDefine34] = f2;
        f5 = heapClassInst.heapFloat[r2 + numDefine7];
        r2 = sp + numDefineNeg176;
        r3 = r2 >> numDefine2;
        heapClassInst.heapFloat[r1 + numDefine35] = f5;
        heapClassInst.heapFloat[r3 + numDefine12] = f0;
        heapClassInst.heapFloat[r3 + numDefine13] = f1;
        heapClassInst.heapFloat[r3 + numDefine14] = f2;
        heapClassInst.heapFloat[r3 + numDefine15] = f5;
        heapClassInst.heapFloat[r3 + numDefine8] = f0;
        heapClassInst.heapFloat[r3 + numDefine9] = f1;
        heapClassInst.heapFloat[r3 + numDefine10] = f2;
        heapClassInst.heapFloat[r3 + numDefine11] = f5;
        heapClassInst.heapFloat[r3 + numDefine4] = f0;
        heapClassInst.heapFloat[r3 + numDefine5] = f1;
        heapClassInst.heapFloat[r3 + numDefine6] = f2;
        heapClassInst.heapFloat[r3 + numDefine7] = f5;
        heapClassInst.heapFloat[fp + numDefineNeg44] = f0;
        heapClassInst.heapFloat[r3 + 1] = f1;
        r4 = (r0 + numDefine148) | 0;
        heapClassInst.heap32[fp + numDefineNeg52] = r4;
        r4 = 0;
        r5 = 1;
        heapClassInst.heap32[fp + numDefineNeg53] = r5;
        heapClassInst.heapFloat[r3 + numDefine2] = f2;
        heapClassInst.heapFloat[r3 + numDefine3] = f5;
        heapClassInst.heap32[fp + numDefineNeg50] = r5;
        r24 = 0;
        repeat5: while (true) {
            f0 = f0 * f0;
            f1 = f1 * f1;
            r3 = heapClassInst.heap32[r1 + numDefine92];
            f0 = f0 + f1;
            f1 = f2 * f2;
            f0 = f0 + f1;
            heapClassInst.heapFloat[g0] = f0;
            sqrtf(i7);
            f0 = (float) commonVariable.fg0;
            f1 = (float) numDefineFloat9165;
            if (f0 >= f1) {
                r5 = heapClassInst.heap32[fp + numDefineNeg53];
                r5 = (r5 - r3) | 0;
                heapClassInst.heap32[fp + numDefineNeg51] = r5;
                f2 = heapClassInst.heapFloat[r1 + numDefine34];
                f5 = heapClassInst.heapFloat[r1 + numDefine33];
                f6 = heapClassInst.heapFloat[r1 + numDefine32];
                r5 = sp + numDefineNeg96;
                f6 = -f6;
                r6 = r5 >> numDefine2;
                f5 = -f5;
                heapClassInst.heapFloat[fp + numDefineNeg24] = f6;
                r3 = (r3 * numDefine36) | 0;
                f2 = -f2;
                heapClassInst.heapFloat[r6 + 1] = f5;
                r7 = (r0 + r3) | 0;
                heapClassInst.heapFloat[r6 + numDefine2] = f2;
                heapClassInst.heap32[r6 + numDefine3] = 0;
                r6 = r7 >> numDefine2;
                r8 = heapClassInst.heap32[r6 + numDefine45];
                r8 = r8 << numDefine2;
                r8 = (r7 + r8) | 0;
                r8 = r8 >> numDefine2;
                heapClassInst.heap32[r8 + numDefine41] = 0;
                r8 = heapClassInst.heap32[r1 + numDefine91];
                r8 = (r8 + -1) | 0;
                r9 = heapClassInst.heap32[r6 + numDefine45];
                r10 = r8 << numDefine2;
                r10 = (r0 + r10) | 0;
                r9 = r9 << numDefine2;
                r7 = (r7 + numDefine148) | 0;
                r9 = (r7 + r9) | 0;
                r10 = r10 >> numDefine2;
                heapClassInst.heap32[r1 + numDefine91] = r8;
                r8 = r9 >> numDefine2;
                r9 = heapClassInst.heap32[r10 + numDefine87];
                heapClassInst.heap32[r8] = r9;
                r8 = heapClassInst.heap32[r6 + numDefine45];
                r9 = r8 << numDefine2;
                r9 = (r7 + r9) | 0;
                r9 = r9 >> numDefine2;
                r9 = heapClassInst.heap32[r9];
                r8 = (r8 + 1) | 0;
                heapClassInst.heap32[r6 + numDefine45] = r8;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r5;
                heapClassInst.heap32[g0 + numDefine2] = r9;
                znk12gjkepa2Impl3GJK10getsupportERK9btVector3RNS03sSVE(i7);
                r5 = heapClassInst.heap32[r6 + numDefine45];
                r8 = r5 << numDefine2;
                r7 = (r8 + r7) | 0;
                r7 = r7 >> numDefine2;
                r7 = heapClassInst.heap32[r7 + -1];
                r8 = 0;
                repeat8: while (true) {
                    if (uint(r8) < uint(numDefine4)) {
                        r9 = r8 << numDefine4;
                        r9 = (r2 + r9) | 0;
                        r10 = r7 >> numDefine2;
                        r9 = r9 >> numDefine2;
                        f2 = heapClassInst.heapFloat[r10 + numDefine4];
                        f5 = heapClassInst.heapFloat[r9];
                        f6 = heapClassInst.heapFloat[r10 + numDefine5];
                        f7 = heapClassInst.heapFloat[r9 + 1];
                        f2 = f2 - f5;
                        f5 = f6 - f7;
                        f6 = heapClassInst.heapFloat[r10 + numDefine6];
                        f7 = heapClassInst.heapFloat[r9 + numDefine2];
                        f6 = f6 - f7;
                        f2 = f2 * f2;
                        f5 = f5 * f5;
                        f2 = f2 + f5;
                        f5 = f6 * f6;
                        f2 = f2 + f5;
                        if (f2 < f1) {
                            label = numDefine10;
                            break repeat5;
                        } else {
                            r8 = (r8 + 1) | 0;
                        }
                    } else {
                        break repeat8;
                    }
                }
                r8 = heapClassInst.heap32[fp + numDefineNeg50];
                r8 = r8 << numDefine4;
                r8 = (r2 + r8) | 0;
                r8 = r8 >> numDefine2;
                r7 = r7 >> numDefine2;
                heapClassInst.heap32[r8] = heapClassInst.heap32[r7 + numDefine4];
                heapClassInst.heap32[r8 + 1] = heapClassInst.heap32[r7 + numDefine5];
                heapClassInst.heap32[r8 + numDefine2] = heapClassInst.heap32[r7 + numDefine6];
                heapClassInst.heap32[r8 + numDefine3] = heapClassInst.heap32[r7 + numDefine7];
                f1 = heapClassInst.heapFloat[r1 + numDefine32];
                f2 = heapClassInst.heapFloat[r7 + numDefine4];
                f5 = heapClassInst.heapFloat[r1 + numDefine33];
                f6 = heapClassInst.heapFloat[r7 + numDefine5];
                f1 = f1 * f2;
                f2 = f5 * f6;
                f5 = heapClassInst.heapFloat[r1 + numDefine34];
                f6 = heapClassInst.heapFloat[r7 + numDefine6];
                f1 = f1 + f2;
                f2 = f5 * f6;
                f1 = f1 + f2;
                f1 = f1 / f0;
                f4 = f1 > f4 ? f1 : f4;
                f1 = (float) -numDefineFloat9165;
                f2 = f0 - f4;
                f0 = f0 * f1;
                f0 = f2 + f0;
                f5 = 0;
                if (f0 > f5) {
                    heapClassInst.heap32[fp + numDefineNeg49] = 0;
                    repeat14: do {
                        if (r5 == numDefine2) {
                            r5 = heapClassInst.heap32[r6 + numDefine38];
                            r7 = heapClassInst.heap32[r6 + numDefine37];
                            r7 = (r7 + numDefine16) | 0;
                            r5 = (r5 + numDefine16) | 0;
                            r8 = sp + numDefineNeg192;
                            r9 = sp + numDefineNeg196;
                            heapClassInst.heap32[g0] = r7;
                            heapClassInst.heap32[g0 + 1] = r5;
                            heapClassInst.heap32[g0 + numDefine2] = r8;
                            heapClassInst.heap32[g0 + numDefine3] = r9;
                            zn12gjkepa2Impl3GJK13projectoriginERK9btVector3S3PfRj(i7);
                            f3 = (float) commonVariable.fg0;
                            label = numDefine32;
                            break repeat14;
                        } else {
                            if (r5 == numDefine3) {
                                r5 = heapClassInst.heap32[r6 + numDefine39];
                                r7 = heapClassInst.heap32[r6 + numDefine38];
                                r8 = heapClassInst.heap32[r6 + numDefine37];
                                r8 = (r8 + numDefine16) | 0;
                                r7 = (r7 + numDefine16) | 0;
                                r5 = (r5 + numDefine16) | 0;
                                r9 = sp + numDefineNeg192;
                                r10 = sp + numDefineNeg196;
                                heapClassInst.heap32[g0] = r8;
                                heapClassInst.heap32[g0 + 1] = r7;
                                heapClassInst.heap32[g0 + numDefine2] = r5;
                                heapClassInst.heap32[g0 + numDefine3] = r9;
                                heapClassInst.heap32[g0 + numDefine4] = r10;
                                zn12gjkepa2Impl3GJK13projectoriginERK9btVector3S3S3PfRj(i7);
                                f3 = (float) commonVariable.fg0;
                                label = numDefine32;
                            } else {
                                if (r5 == numDefine4) {
                                    r5 = heapClassInst.heap32[r6 + numDefine40];
                                    r7 = heapClassInst.heap32[r6 + numDefine39];
                                    r8 = heapClassInst.heap32[r6 + numDefine38];
                                    r9 = heapClassInst.heap32[r6 + numDefine37];
                                    r10 = sp + numDefineNeg16;
                                    r11 = (r9 + numDefine16) | 0;
                                    r12 = r10 >> numDefine2;
                                    r13 = (r8 + numDefine16) | 0;
                                    heapClassInst.heap32[fp + numDefineNeg4] = r11;
                                    r11 = (r7 + numDefine16) | 0;
                                    heapClassInst.heap32[r12 + 1] = r13;
                                    r13 = (r5 + numDefine16) | 0;
                                    heapClassInst.heap32[r12 + numDefine2] = r11;
                                    r9 = r9 >> numDefine2;
                                    heapClassInst.heap32[r12 + numDefine3] = r13;
                                    r5 = r5 >> numDefine2;
                                    f0 = heapClassInst.heapFloat[r9 + numDefine6];
                                    f1 = heapClassInst.heapFloat[r5 + numDefine6];
                                    f2 = heapClassInst.heapFloat[r9 + numDefine5];
                                    f3 = heapClassInst.heapFloat[r5 + numDefine5];
                                    f6 = heapClassInst.heapFloat[r9 + numDefine4];
                                    f7 = heapClassInst.heapFloat[r5 + numDefine4];
                                    r11 = sp + numDefineNeg64;
                                    f8 = f6 - f7;
                                    f9 = f2 - f3;
                                    r12 = r11 >> numDefine2;
                                    heapClassInst.heapFloat[fp + numDefineNeg16] = f8;
                                    f10 = f0 - f1;
                                    heapClassInst.heapFloat[r12 + 1] = f9;
                                    heapClassInst.heapFloat[r12 + numDefine2] = f10;
                                    r8 = r8 >> numDefine2;
                                    heapClassInst.heap32[r12 + numDefine3] = 0;
                                    f11 = heapClassInst.heapFloat[r8 + numDefine6];
                                    f12 = heapClassInst.heapFloat[r8 + numDefine5];
                                    f13 = heapClassInst.heapFloat[r8 + numDefine4];
                                    f14 = f13 - f7;
                                    f15 = f12 - f3;
                                    heapClassInst.heapFloat[r12 + numDefine4] = f14;
                                    f16 = f11 - f1;
                                    heapClassInst.heapFloat[r12 + numDefine5] = f15;
                                    heapClassInst.heapFloat[r12 + numDefine6] = f16;
                                    r7 = r7 >> numDefine2;
                                    heapClassInst.heap32[r12 + numDefine7] = 0;
                                    f17 = heapClassInst.heapFloat[r7 + numDefine5];
                                    f18 = heapClassInst.heapFloat[r7 + numDefine4];
                                    f19 = f9 * f16;
                                    f7 = f18 - f7;
                                    f20 = f10 * f14;
                                    f3 = f17 - f3;
                                    f21 = heapClassInst.heapFloat[r7 + numDefine6];
                                    f16 = f8 * f16;
                                    f19 = f19 * f7;
                                    f20 = f20 * f3;
                                    f22 = f11 - f21;
                                    f23 = f2 - f12;
                                    f18 = f13 - f18;
                                    f11 = f0 - f11;
                                    f12 = f12 - f17;
                                    f13 = f6 - f13;
                                    f17 = f19 + f20;
                                    f16 = f16 * f3;
                                    f14 = f9 * f14;
                                    f1 = f21 - f1;
                                    f19 = f8 * f15;
                                    f20 = f12 * f11;
                                    f21 = f22 * f23;
                                    f22 = f22 * f13;
                                    f11 = f18 * f11;
                                    f16 = f17 - f16;
                                    f14 = f14 * f1;
                                    f17 = f20 - f21;
                                    f11 = f22 - f11;
                                    f15 = f10 * f15;
                                    heapClassInst.heapFloat[r12 + numDefine8] = f7;
                                    f18 = f18 * f23;
                                    f12 = f12 * f13;
                                    f13 = f16 - f14;
                                    f14 = f19 * f1;
                                    f12 = f18 - f12;
                                    heapClassInst.heapFloat[r12 + numDefine9] = f3;
                                    f3 = f6 * f17;
                                    f2 = f2 * f11;
                                    f6 = f13 + f14;
                                    f7 = f15 * f7;
                                    f6 = f6 - f7;
                                    heapClassInst.heapFloat[r12 + numDefine10] = f1;
                                    f1 = f3 + f2;
                                    f0 = f0 * f12;
                                    f0 = f1 + f0;
                                    heapClassInst.heap32[r12 + numDefine11] = 0;
                                    f0 = f0 * f6;
                                    if (f0 > f5) {
                                        label = numDefine42;
                                        break repeat5;
                                    } else {
                                        if (f6 < f5) {
                                            f0 = -f6;
                                        } else {
                                            f0 = f6;
                                        }
                                        if (f0 <= f5) {
                                            label = numDefine42;
                                            break repeat5;
                                        } else {
                                            r12 = sp + numDefineNeg76;
                                            r14 = r12 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg19] = 0;
                                            heapClassInst.heap32[r14 + 1] = 0;
                                            r15 = 0;
                                            f3 = -1;
                                            heapClassInst.heap32[r14 + numDefine2] = 0;
                                            heapClassInst.heap32[fp + numDefineNeg20] = 0;
                                            repeat27: while (true) {
                                                r16 = zzn12gjkepa2Impl3GJK13projectoriginERK9btVector3S3S3PfRjE4imd3;
                                                r17 = r15 << numDefine2;
                                                r18 = (r16 + r17) | 0;
                                                r18 = r18 >> numDefine2;
                                                r18 = heapClassInst.heap32[r18];
                                                r19 = r18 << numDefine4;
                                                r19 = (r11 + r19) | 0;
                                                r19 = r19 >> numDefine2;
                                                f0 = heapClassInst.heapFloat[r19 + 1];
                                                f1 = heapClassInst.heapFloat[r19 + numDefine2];
                                                f2 = heapClassInst.heapFloat[r19];
                                                f7 = f9 * f1;
                                                f11 = f10 * f0;
                                                f10 = f10 * f2;
                                                f1 = f8 * f1;
                                                f12 = heapClassInst.heapFloat[r5 + numDefine4];
                                                f7 = f7 - f11;
                                                f11 = heapClassInst.heapFloat[r5 + numDefine5];
                                                f1 = f10 - f1;
                                                f0 = f8 * f0;
                                                f2 = f9 * f2;
                                                f8 = f12 * f7;
                                                f1 = f11 * f1;
                                                f9 = heapClassInst.heapFloat[r5 + numDefine6];
                                                f0 = f0 - f2;
                                                f1 = f8 + f1;
                                                f0 = f9 * f0;
                                                f0 = f1 + f0;
                                                f0 = f0 * f6;
                                                repeat29: do {
                                                    if (f0 > f5) {
                                                        r19 = r18 << numDefine2;
                                                        r20 = (r10 + r19) | 0;
                                                        r21 = (r10 + r17) | 0;
                                                        r20 = r20 >> numDefine2;
                                                        r21 = r21 >> numDefine2;
                                                        r20 = heapClassInst.heap32[r20];
                                                        r21 = heapClassInst.heap32[r21];
                                                        r22 = sp + numDefineNeg80;
                                                        heapClassInst.heap32[g0] = r21;
                                                        heapClassInst.heap32[g0 + 1] = r20;
                                                        heapClassInst.heap32[g0 + numDefine2] = r13;
                                                        heapClassInst.heap32[g0 + numDefine3] = r12;
                                                        heapClassInst.heap32[g0 + numDefine4] = r22;
                                                        zn12gjkepa2Impl3GJK13projectoriginERK9btVector3S3S3PfRj(i7);
                                                        f0 = (float) commonVariable.fg0;
                                                        f1 = 0;
                                                        if (!(f3 < f1)) {
                                                            if (f0 >= f3) {
                                                                break repeat29;
                                                            }
                                                        }
                                                        r20 = heapClassInst.heap32[fp + numDefineNeg20];
                                                        r21 = 1;
                                                        r22 = r20 & 1;
                                                        r23 = r21 << r15;
                                                        r25 = r20 & numDefine2;
                                                        r18 = r21 << r18;
                                                        r16 = (r16 + r19) | 0;
                                                        r21 = r22 == 0 ? r24 : r23;
                                                        r18 = r25 == 0 ? r24 : r18;
                                                        r20 = r20 & numDefine4;
                                                        r22 = numDefine8;
                                                        r23 = sp + numDefineNeg192;
                                                        r16 = r16 >> numDefine2;
                                                        r18 = (r21 + r18) | 0;
                                                        r20 = r20 == 0 ? r24 : r22;
                                                        r16 = heapClassInst.heap32[r16];
                                                        r17 = (r23 + r17) | 0;
                                                        r18 = (r18 + r20) | 0;
                                                        r16 = r16 << numDefine2;
                                                        r19 = (r23 + r19) | 0;
                                                        r17 = r17 >> numDefine2;
                                                        heapClassInst.heap32[fp + numDefineNeg49] = r18;
                                                        r16 = (r23 + r16) | 0;
                                                        r18 = r19 >> numDefine2;
                                                        heapClassInst.heap32[r17] = heapClassInst.heap32[fp + numDefineNeg19];
                                                        r16 = r16 >> numDefine2;
                                                        heapClassInst.heap32[r18] = heapClassInst.heap32[r14 + 1];
                                                        r17 = r23 >> numDefine2;
                                                        heapClassInst.heap32[r16] = 0;
                                                        heapClassInst.heap32[r17 + numDefine3] = heapClassInst.heap32[r14 + numDefine3];
                                                        f3 = f0;
                                                    }
                                                } while (false);
                                                if (r15 == numDefine2) {
                                                    break repeat27;
                                                } else {
                                                    r16 = (r15 + 1) | 0;
                                                    r15 = r15 << numDefine4;
                                                    r15 = (r11 + r15) | 0;
                                                    r15 = r15 >> numDefine2;
                                                    f8 = heapClassInst.heapFloat[r15 + numDefine4];
                                                    f9 = heapClassInst.heapFloat[r15 + numDefine5];
                                                    f10 = heapClassInst.heapFloat[r15 + numDefine6];
                                                    r15 = r16;
                                                }
                                            }
                                            if (f3 < f5) {
                                                heapClassInst.heap32[fp + numDefineNeg49] = numDefine15;
                                                f0 = heapClassInst.heapFloat[r7 + numDefine5];
                                                f1 = heapClassInst.heapFloat[r8 + numDefine6];
                                                f2 = heapClassInst.heapFloat[r8 + numDefine4];
                                                f3 = heapClassInst.heapFloat[r7 + numDefine6];
                                                f7 = heapClassInst.heapFloat[r7 + numDefine4];
                                                f8 = f0 * f1;
                                                f9 = heapClassInst.heapFloat[r5 + numDefine4];
                                                f10 = f3 * f2;
                                                f11 = heapClassInst.heapFloat[r5 + numDefine5];
                                                f12 = f7 * f1;
                                                f8 = f8 * f9;
                                                f10 = f10 * f11;
                                                f13 = heapClassInst.heapFloat[r8 + numDefine5];
                                                f14 = heapClassInst.heapFloat[r5 + numDefine6];
                                                f15 = f0 * f2;
                                                f8 = f8 + f10;
                                                f10 = f12 * f11;
                                                f12 = f7 * f13;
                                                f8 = f8 - f10;
                                                f10 = f15 * f14;
                                                f15 = f3 * f13;
                                                f8 = f8 - f10;
                                                f10 = f12 * f14;
                                                f8 = f8 + f10;
                                                f10 = f15 * f9;
                                                f8 = f8 - f10;
                                                f8 = f8 / f6;
                                                heapClassInst.heapFloat[fp + numDefineNeg48] = f8;
                                                f10 = heapClassInst.heapFloat[r9 + numDefine5];
                                                f12 = heapClassInst.heapFloat[r9 + numDefine6];
                                                f15 = heapClassInst.heapFloat[r9 + numDefine4];
                                                f16 = f10 * f3;
                                                f17 = f12 * f7;
                                                f18 = f13 * f12;
                                                f19 = f1 * f15;
                                                f3 = f15 * f3;
                                                f16 = f16 * f9;
                                                f17 = f17 * f11;
                                                f20 = f2 * f12;
                                                f7 = f10 * f7;
                                                f18 = f18 * f9;
                                                f19 = f19 * f11;
                                                f16 = f16 + f17;
                                                f3 = f3 * f11;
                                                f13 = f13 * f15;
                                                f15 = f15 * f0;
                                                f17 = f18 + f19;
                                                f11 = f20 * f11;
                                                f3 = f16 - f3;
                                                f7 = f7 * f14;
                                                f2 = f2 * f10;
                                                f0 = f12 * f0;
                                                f11 = f17 - f11;
                                                f12 = f13 * f14;
                                                f3 = f3 - f7;
                                                f7 = f15 * f14;
                                                f1 = f1 * f10;
                                                f10 = f11 - f12;
                                                f2 = f2 * f14;
                                                f3 = f3 + f7;
                                                f0 = f0 * f9;
                                                f0 = f3 - f0;
                                                f2 = f10 + f2;
                                                f1 = f1 * f9;
                                                r5 = sp + numDefineNeg192;
                                                f1 = f2 - f1;
                                                f0 = f0 / f6;
                                                r5 = r5 >> numDefine2;
                                                f2 = f8 + f0;
                                                f1 = f1 / f6;
                                                heapClassInst.heapFloat[r5 + 1] = f0;
                                                f0 = 1;
                                                f2 = f2 + f1;
                                                r7 = numDefine15;
                                                f0 = f0 - f2;
                                                heapClassInst.heapFloat[r5 + numDefine2] = f1;
                                                heapClassInst.heapFloat[r5 + numDefine3] = f0;
                                                label = numDefine34;
                                            } else {
                                                label = numDefine32;
                                            }
                                        }
                                    }
                                } else {
                                    label = numDefine32;
                                }
                            }
                        }
                    } while (false);
                    if (label == numDefine32) {
                        f0 = 0;
                        if (f3 < f0) {
                            label = numDefine42;
                            break repeat5;
                        } else {
                            r7 = heapClassInst.heap32[fp + numDefineNeg49];
                            f5 = f3;
                        }
                    }
                    r5 = heapClassInst.heap32[fp + numDefineNeg51];
                    r8 = (r5 * numDefine36) | 0;
                    r8 = (r0 + r8) | 0;
                    r9 = r8 >> numDefine2;
                    heapClassInst.heap32[r9 + numDefine45] = 0;
                    heapClassInst.heap32[r1 + numDefine32] = 0;
                    heapClassInst.heap32[r1 + numDefine33] = 0;
                    heapClassInst.heap32[r1 + numDefine34] = 0;
                    heapClassInst.heap32[r1 + numDefine35] = 0;
                    heapClassInst.heap32[r1 + numDefine92] = r5;
                    r5 = heapClassInst.heap32[r6 + numDefine45];
                    repeat42: do {
                        if (!(r5 == 0)) {
                            r6 = heapClassInst.heap32[fp + numDefineNeg52];
                            r3 = (r6 + r3) | 0;
                            r6 = 0;
                            while (true) {
                                r10 = 1;
                                r10 = r10 << r6;
                                r10 = r7 & r10;
                                if (r10 == 0) {
                                    r10 = r6 << numDefine2;
                                    r11 = heapClassInst.heap32[r1 + numDefine91];
                                    r10 = (r3 + r10) | 0;
                                    r12 = r11 << numDefine2;
                                    r10 = r10 >> numDefine2;
                                    r12 = (r0 + r12) | 0;
                                    r10 = heapClassInst.heap32[r10];
                                    r12 = r12 >> numDefine2;
                                    r11 = (r11 + 1) | 0;
                                    heapClassInst.heap32[r12 + numDefine87] = r10;
                                    heapClassInst.heap32[r1 + numDefine91] = r11;
                                } else {
                                    r10 = r6 << numDefine2;
                                    r11 = (r3 + r10) | 0;
                                    r12 = heapClassInst.heap32[r9 + numDefine45];
                                    r11 = r11 >> numDefine2;
                                    r13 = (r8 + numDefine148) | 0;
                                    r12 = r12 << numDefine2;
                                    r12 = (r13 + r12) | 0;
                                    r14 = heapClassInst.heap32[r11];
                                    r12 = r12 >> numDefine2;
                                    r15 = sp + numDefineNeg192;
                                    heapClassInst.heap32[r12] = r14;
                                    r12 = heapClassInst.heap32[r9 + numDefine45];
                                    r10 = (r15 + r10) | 0;
                                    r14 = r12 << numDefine2;
                                    r10 = r10 >> numDefine2;
                                    r13 = (r13 + r14) | 0;
                                    f0 = heapClassInst.heapFloat[r10];
                                    r10 = r13 >> numDefine2;
                                    r12 = (r12 + 1) | 0;
                                    heapClassInst.heapFloat[r10 + numDefine4] = f0;
                                    heapClassInst.heap32[r9 + numDefine45] = r12;
                                    r10 = heapClassInst.heap32[r11];
                                    r10 = r10 >> numDefine2;
                                    f1 = heapClassInst.heapFloat[r10 + numDefine4];
                                    f2 = heapClassInst.heapFloat[r10 + numDefine6];
                                    f3 = heapClassInst.heapFloat[r10 + numDefine5];
                                    f6 = heapClassInst.heapFloat[r1 + numDefine32];
                                    f1 = f1 * f0;
                                    f1 = f6 + f1;
                                    heapClassInst.heapFloat[r1 + numDefine32] = f1;
                                    f1 = f3 * f0;
                                    f3 = heapClassInst.heapFloat[r1 + numDefine33];
                                    f1 = f3 + f1;
                                    heapClassInst.heapFloat[r1 + numDefine33] = f1;
                                    f0 = f2 * f0;
                                    f1 = heapClassInst.heapFloat[r1 + numDefine34];
                                    f0 = f1 + f0;
                                    heapClassInst.heapFloat[r1 + numDefine34] = f0;
                                }
                                r6 = (r6 + 1) | 0;
                                if (!(r5 != r6)) {
                                    break repeat42;
                                }
                            }
                        }
                    } while (false);
                    if (!(r7 != numDefine15)) {
                        heapClassInst.heap32[r1 + numDefine94] = 1;
                    }
                    r4 = (r4 + 1) | 0;
                    if (uint(r4) < uint(numDefine128)) {
                        r3 = heapClassInst.heap32[r1 + numDefine94];
                        if (r3 != 0) {
                            label = numDefine47;
                            break repeat5;
                        } else {
                            r5 = heapClassInst.heap32[fp + numDefineNeg50];
                            r3 = (r5 + 1) | 0;
                            f0 = heapClassInst.heapFloat[r1 + numDefine32];
                            f1 = heapClassInst.heapFloat[r1 + numDefine33];
                            f2 = heapClassInst.heapFloat[r1 + numDefine34];
                            r5 = r3 & numDefine3;
                            heapClassInst.heap32[fp + numDefineNeg50] = r5;
                            f3 = f5;
                            continue repeat5;
                        }
                    } else {
                        label = numDefine44;
                        break repeat5;
                    }
                } else {
                    label = numDefine12;
                    break repeat5;
                }
            } else {
                label = numDefine5;
                break repeat5;
            }
        }
        switch (label) {
            case numDefine10:
                r2 = heapClassInst.heap32[r1 + numDefine92];
                r2 = (r2 * numDefine36) | 0;
                r2 = (r0 + r2) | 0;
                r3 = r2 >> numDefine2;
                r4 = heapClassInst.heap32[r3 + numDefine45];
                r4 = (r4 + -1) | 0;
                r5 = r4 << numDefine2;
                r6 = heapClassInst.heap32[r1 + numDefine91];
                r2 = (r2 + r5) | 0;
                r5 = r6 << numDefine2;
                r2 = (r2 + numDefine148) | 0;
                r5 = (r0 + r5) | 0;
                r2 = r2 >> numDefine2;
                heapClassInst.heap32[r3 + numDefine45] = r4;
                r3 = r5 >> numDefine2;
                r2 = heapClassInst.heap32[r2];
                r4 = (r6 + 1) | 0;
                heapClassInst.heap32[r3 + numDefine87] = r2;
                heapClassInst.heap32[r1 + numDefine91] = r4;
                break;
            case numDefine42:
                r2 = heapClassInst.heap32[r1 + numDefine92];
                r2 = (r2 * numDefine36) | 0;
                r2 = (r0 + r2) | 0;
                r4 = r2 >> numDefine2;
                r3 = heapClassInst.heap32[r4 + numDefine45];
                r3 = (r3 + -1) | 0;
                r5 = r3 << numDefine2;
                r6 = heapClassInst.heap32[r1 + numDefine91];
                r2 = (r2 + r5) | 0;
                r5 = r6 << numDefine2;
                r2 = (r2 + numDefine148) | 0;
                r5 = (r0 + r5) | 0;
                r2 = r2 >> numDefine2;
                heapClassInst.heap32[r4 + numDefine45] = r3;
                r4 = r5 >> numDefine2;
                r2 = heapClassInst.heap32[r2];
                r3 = (r6 + 1) | 0;
                heapClassInst.heap32[r4 + numDefine87] = r2;
                heapClassInst.heap32[r1 + numDefine91] = r3;
                break;
            case numDefine5:
                heapClassInst.heap32[r1 + numDefine94] = 1;
                break;
            case numDefine44:
                heapClassInst.heap32[r1 + numDefine94] = numDefine2;
                break;
            case numDefine12:
                r2 = heapClassInst.heap32[r1 + numDefine92];
                r2 = (r2 * numDefine36) | 0;
                r2 = (r0 + r2) | 0;
                r3 = r2 >> numDefine2;
                r4 = heapClassInst.heap32[r3 + numDefine45];
                r4 = (r4 + -1) | 0;
                r5 = r4 << numDefine2;
                r6 = heapClassInst.heap32[r1 + numDefine91];
                r2 = (r2 + r5) | 0;
                r5 = r6 << numDefine2;
                r2 = (r2 + numDefine148) | 0;
                r5 = (r0 + r5) | 0;
                r2 = r2 >> numDefine2;
                heapClassInst.heap32[r3 + numDefine45] = r4;
                r3 = r5 >> numDefine2;
                r2 = heapClassInst.heap32[r2];
                r4 = (r6 + 1) | 0;
                heapClassInst.heap32[r3 + numDefine87] = r2;
                heapClassInst.heap32[r1 + numDefine91] = r4;
                break;
            default:
                break;
        }
        r2 = heapClassInst.heap32[r1 + numDefine92];
        r2 = (r2 * numDefine36) | 0;
        r0 = (r0 + r2) | 0;
        r0 = (r0 + numDefine148) | 0;
        heapClassInst.heap32[r1 + numDefine93] = r0;
        r0 = heapClassInst.heap32[r1 + numDefine94];
        if (r0 == 1) {
            heapClassInst.heap32[r1 + numDefine36] = 0;
            r0 = 1;
        } else {
            if (!(r0 != 0)) {
                f0 = heapClassInst.heapFloat[r1 + numDefine32];
                f1 = heapClassInst.heapFloat[r1 + numDefine33];
                f2 = heapClassInst.heapFloat[r1 + numDefine34];
                f0 = f0 * f0;
                f1 = f1 * f1;
                f0 = f0 + f1;
                f1 = f2 * f2;
                f0 = f0 + f1;
                heapClassInst.heapFloat[g0] = f0;
                sqrtf(i7);
                heapClassInst.heapFloat[r1 + numDefine36] = (float) commonVariable.fg0;
                r0 = heapClassInst.heap32[r1 + numDefine94];
                commonVariable.rg0 = r0;
                return;
            }
        }
        commonVariable.rg0 = r0;
        return;
    }

    public static void zn12gjkepa2Impl3EPA7newfaceEPNS3GJK3sSVES3S3B(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + numDefine2450];
        repeat1: do {
            if (r1 == 0) {
                heapClassInst.heap32[r0] = numDefine5;
                r1 = 0;
            } else {
                r2 = r1 >> numDefine2;
                r3 = heapClassInst.heap32[r2 + numDefine13];
                if (!(r3 == 0)) {
                    r3 = r3 >> numDefine2;
                    r4 = heapClassInst.heap32[r2 + numDefine12];
                    heapClassInst.heap32[r3 + numDefine12] = r4;
                }
                r3 = heapClassInst.heap32[r2 + numDefine12];
                if (!(r3 == 0)) {
                    r3 = r3 >> numDefine2;
                    r4 = heapClassInst.heap32[r2 + numDefine13];
                    heapClassInst.heap32[r3 + numDefine13] = r4;
                }
                r3 = heapClassInst.heap32[r0 + numDefine2450];
                if (!(r3 != r1)) {
                    r3 = heapClassInst.heap32[r2 + numDefine13];
                    heapClassInst.heap32[r0 + numDefine2450] = r3;
                }
                r3 = heapClassInst.heap32[r0 + numDefine2451];
                r3 = (r3 + -1) | 0;
                heapClassInst.heap32[r0 + numDefine2451] = r3;
                heapClassInst.heap32[r2 + numDefine12] = 0;
                r3 = heapClassInst.heap32[r0 + numDefine2448];
                heapClassInst.heap32[r2 + numDefine13] = r3;
                r3 = heapClassInst.heap32[r0 + numDefine2448];
                if (!(r3 == 0)) {
                    r3 = r3 >> numDefine2;
                    heapClassInst.heap32[r3 + numDefine12] = r1;
                }
                r3 = heapClassInst.heap32[fp + 1];
                r4 = heapClassInst.heap32[fp + numDefine2];
                r5 = heapClassInst.heap32[fp + numDefine3];
                heapClassInst.heap32[r0 + numDefine2448] = r1;
                r6 = heapClassInst.heap32[r0 + numDefine2449];
                r6 = (r6 + 1) | 0;
                r7 = 0;
                heapClassInst.heap32[r0 + numDefine2449] = r6;
                heapClassInst.heap8[r1 + numDefine59] = (byte) r7;
                heapClassInst.heap32[r2 + numDefine6] = r3;
                heapClassInst.heap32[r2 + numDefine7] = r4;
                heapClassInst.heap32[r2 + numDefine8] = r5;
                r5 = r5 >> numDefine2;
                r3 = r3 >> numDefine2;
                r4 = r4 >> numDefine2;
                f0 = heapClassInst.heapFloat[r5 + numDefine6];
                f1 = heapClassInst.heapFloat[r3 + numDefine6];
                f2 = heapClassInst.heapFloat[r4 + numDefine6];
                f3 = heapClassInst.heapFloat[r5 + numDefine5];
                f4 = heapClassInst.heapFloat[r3 + numDefine5];
                f5 = heapClassInst.heapFloat[r4 + numDefine5];
                f5 = f5 - f4;
                f0 = f0 - f1;
                f1 = f2 - f1;
                f2 = f3 - f4;
                f3 = heapClassInst.heapFloat[r5 + numDefine4];
                f4 = heapClassInst.heapFloat[r3 + numDefine4];
                f6 = heapClassInst.heapFloat[r4 + numDefine4];
                f3 = f3 - f4;
                f4 = f6 - f4;
                f6 = f5 * f0;
                f7 = f1 * f2;
                f6 = f6 - f7;
                f1 = f1 * f3;
                f0 = f4 * f0;
                f0 = f1 - f0;
                heapClassInst.heapFloat[r2] = f6;
                f1 = f4 * f2;
                f2 = f5 * f3;
                f1 = f1 - f2;
                heapClassInst.heapFloat[r2 + 1] = f0;
                heapClassInst.heapFloat[r2 + numDefine2] = f1;
                f2 = f6 * f6;
                f0 = f0 * f0;
                heapClassInst.heap32[r2 + numDefine3] = 0;
                f0 = f2 + f0;
                f1 = f1 * f1;
                f0 = f0 + f1;
                heapClassInst.heapFloat[g0] = f0;
                sqrtf(i7);
                f0 = (float) commonVariable.fg0;
                f1 = heapClassInst.heapFloat[r5 + numDefine6];
                f2 = heapClassInst.heapFloat[r3 + numDefine6];
                f3 = heapClassInst.heapFloat[r4 + numDefine6];
                f4 = heapClassInst.heapFloat[r5 + numDefine5];
                f5 = heapClassInst.heapFloat[r3 + numDefine5];
                f6 = heapClassInst.heapFloat[r4 + numDefine5];
                f7 = heapClassInst.heapFloat[r5 + numDefine4];
                f8 = heapClassInst.heapFloat[r3 + numDefine4];
                f9 = heapClassInst.heapFloat[r4 + numDefine4];
                f10 = heapClassInst.heapFloat[r2];
                f11 = f2 - f3;
                f12 = heapClassInst.heapFloat[r2 + 1];
                f13 = f3 - f1;
                f14 = heapClassInst.heapFloat[r2 + numDefine2];
                f15 = f5 - f6;
                f16 = f8 - f9;
                f17 = f6 - f4;
                f18 = f9 - f7;
                f19 = f1 - f2;
                f20 = f4 - f5;
                f21 = f7 - f8;
                f22 = f12 * f11;
                f23 = f14 * f15;
                f24 = f14 * f16;
                f11 = f10 * f11;
                f25 = f12 * f13;
                f26 = f14 * f17;
                f27 = f14 * f18;
                f13 = f10 * f13;
                f22 = f22 - f23;
                f11 = f24 - f11;
                f23 = f25 - f26;
                f13 = f27 - f13;
                f15 = f10 * f15;
                f16 = f12 * f16;
                f17 = f10 * f17;
                f18 = f12 * f18;
                f24 = f12 * f19;
                f25 = f14 * f20;
                f26 = f14 * f21;
                f19 = f10 * f19;
                f15 = f15 - f16;
                f16 = f17 - f18;
                f17 = f24 - f25;
                f18 = f26 - f19;
                f8 = f8 * f22;
                f5 = f5 * f11;
                f9 = f9 * f23;
                f6 = f6 * f13;
                f11 = f10 * f20;
                f13 = f12 * f21;
                f11 = f11 - f13;
                f5 = f8 + f5;
                f2 = f2 * f15;
                f6 = f9 + f6;
                f3 = f3 * f16;
                f7 = f7 * f17;
                f4 = f4 * f18;
                f2 = f5 + f2;
                f3 = f6 + f3;
                f4 = f7 + f4;
                f1 = f1 * f11;
                f5 = (float) numDefineFloat9165;
                f6 = 1;
                f2 = f2 < f3 ? f2 : f3;
                f1 = f4 + f1;
                f1 = f2 < f1 ? f2 : f1;
                f2 = f0 > f5 ? f0 : f6;
                f1 = f1 / f2;
                f2 = (float) numDefineNegFloat021;
                f3 = 0;
                f1 = f1 < f2 ? f1 : f3;
                heapClassInst.heapFloat[r2 + numDefine5] = f1;
                if (f0 <= f5) {
                    heapClassInst.heap32[r0] = numDefine2;
                } else {
                    r4 = heapClassInst.heap32[fp + numDefine4];
                    f1 = heapClassInst.heapFloat[r3 + numDefine4];
                    f2 = heapClassInst.heapFloat[r3 + numDefine5];
                    f3 = heapClassInst.heapFloat[r3 + numDefine6];
                    f1 = f1 * f10;
                    f2 = f2 * f12;
                    f1 = f1 + f2;
                    f2 = f3 * f14;
                    f1 = f1 + f2;
                    f2 = f6 / f0;
                    f0 = f1 / f0;
                    f1 = f10 * f2;
                    heapClassInst.heapFloat[r2 + numDefine4] = f0;
                    f3 = f12 * f2;
                    heapClassInst.heapFloat[r2] = f1;
                    f1 = f14 * f2;
                    heapClassInst.heapFloat[r2 + 1] = f3;
                    heapClassInst.heapFloat[r2 + numDefine2] = f1;
                    if (r4 != 0) {
                        break repeat1;
                    } else {
                        f1 = (float) -numDefineFloat9166;
                        if (f0 >= f1) {
                            break repeat1;
                        } else {
                            heapClassInst.heap32[r0] = numDefine3;
                        }
                    }
                }
                r3 = heapClassInst.heap32[r2 + numDefine13];
                if (!(r3 == 0)) {
                    r3 = r3 >> numDefine2;
                    r4 = heapClassInst.heap32[r2 + numDefine12];
                    heapClassInst.heap32[r3 + numDefine12] = r4;
                }
                r3 = heapClassInst.heap32[r2 + numDefine12];
                if (!(r3 == 0)) {
                    r3 = r3 >> numDefine2;
                    r4 = heapClassInst.heap32[r2 + numDefine13];
                    heapClassInst.heap32[r3 + numDefine13] = r4;
                }
                r3 = heapClassInst.heap32[r0 + numDefine2448];
                if (!(r3 != r1)) {
                    r3 = heapClassInst.heap32[r2 + numDefine13];
                    heapClassInst.heap32[r0 + numDefine2448] = r3;
                }
                r3 = heapClassInst.heap32[r0 + numDefine2449];
                r3 = (r3 + -1) | 0;
                heapClassInst.heap32[r0 + numDefine2449] = r3;
                heapClassInst.heap32[r2 + numDefine12] = 0;
                r3 = heapClassInst.heap32[r0 + numDefine2450];
                heapClassInst.heap32[r2 + numDefine13] = r3;
                r2 = heapClassInst.heap32[r0 + numDefine2450];
                if (!(r2 == 0)) {
                    r2 = r2 >> numDefine2;
                    heapClassInst.heap32[r2 + numDefine12] = r1;
                }
                heapClassInst.heap32[r0 + numDefine2450] = r1;
                r1 = heapClassInst.heap32[r0 + numDefine2451];
                r1 = (r1 + 1) | 0;
                heapClassInst.heap32[r0 + numDefine2451] = r1;
                r0 = 0;
                commonVariable.rg0 = r0;
                return;
            }
        } while (false);
        commonVariable.rg0 = r1;
        return;
    }

    public static void zn12gjkepa2Impl3EPA6expandEjPNS3GJK3sSVEPNS05sFaceEjRNS08sHorizonE(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine3];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heapU8[r0 + numDefine59];
        repeat1: do {
            if (!(r2 == r1)) {
                r2 = heapClassInst.heap32[fp];
                r3 = heapClassInst.heap32[fp + numDefine2];
                r4 = heapClassInst.heap32[fp + numDefine4];
                r5 = heapClassInst.heap32[fp + numDefine5];
                r6 = r0 >> numDefine2;
                r7 = r3 >> numDefine2;
                f0 = heapClassInst.heapFloat[r6];
                f1 = heapClassInst.heapFloat[r7 + numDefine4];
                f2 = heapClassInst.heapFloat[r6 + 1];
                f3 = heapClassInst.heapFloat[r7 + numDefine5];
                r8 = zzn12gjkepa2Impl3GJK13projectoriginERK9btVector3S3S3PfRjE4imd3;
                r9 = r4 << numDefine2;
                r8 = (r8 + r9) | 0;
                f0 = f0 * f1;
                f1 = f2 * f3;
                f2 = heapClassInst.heapFloat[r6 + numDefine2];
                f3 = heapClassInst.heapFloat[r7 + numDefine6];
                r7 = r8 >> numDefine2;
                f0 = f0 + f1;
                f1 = f2 * f3;
                r7 = heapClassInst.heap32[r7];
                f0 = f0 + f1;
                f1 = heapClassInst.heapFloat[r6 + numDefine4];
                f0 = f0 - f1;
                f1 = (float) numDefineNegFloat9166;
                if (f0 >= f1) {
                    r4 = r7 << numDefine2;
                    r4 = (r0 + r4) | 0;
                    r7 = (r0 + r7) | 0;
                    heapClassInst.heap8[r0 + numDefine59] = (byte) r1;
                    r4 = r4 >> numDefine2;
                    r7 = heapClassInst.heapU8[r7 + numDefine56];
                    r4 = heapClassInst.heap32[r4 + numDefine9];
                    r8 = zzn12gjkepa2Impl3EPA6expandEjPNS3GJK3sSVEPNS05sFaceEjRNS08sHorizonEE4i2m3;
                    r8 = (r8 + r9) | 0;
                    r8 = r8 >> numDefine2;
                    heapClassInst.heap32[g0] = r2;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = r3;
                    heapClassInst.heap32[g0 + numDefine3] = r4;
                    heapClassInst.heap32[g0 + numDefine4] = r7;
                    heapClassInst.heap32[g0 + numDefine5] = r5;
                    r4 = heapClassInst.heap32[r8];
                    zn12gjkepa2Impl3EPA6expandEjPNS3GJK3sSVEPNS05sFaceEjRNS08sHorizonE(i7);
                    r7 = commonVariable.rg0;
                    if (r7 == 0) {
                        break repeat1;
                    } else {
                        r7 = r4 << numDefine2;
                        r7 = (r0 + r7) | 0;
                        r4 = (r0 + r4) | 0;
                        r7 = r7 >> numDefine2;
                        r4 = heapClassInst.heapU8[r4 + numDefine56];
                        r7 = heapClassInst.heap32[r7 + numDefine9];
                        heapClassInst.heap32[g0] = r2;
                        heapClassInst.heap32[g0 + 1] = r1;
                        heapClassInst.heap32[g0 + numDefine2] = r3;
                        heapClassInst.heap32[g0 + numDefine3] = r7;
                        heapClassInst.heap32[g0 + numDefine4] = r4;
                        heapClassInst.heap32[g0 + numDefine5] = r5;
                        zn12gjkepa2Impl3EPA6expandEjPNS3GJK3sSVEPNS05sFaceEjRNS08sHorizonE(i7);
                        r1 = commonVariable.rg0;
                        if (r1 != 0) {
                            r1 = heapClassInst.heap32[r6 + numDefine13];
                            if (!(r1 == 0)) {
                                r1 = r1 >> numDefine2;
                                r3 = heapClassInst.heap32[r6 + numDefine12];
                                heapClassInst.heap32[r1 + numDefine12] = r3;
                            }
                            r1 = heapClassInst.heap32[r6 + numDefine12];
                            if (!(r1 == 0)) {
                                r1 = r1 >> numDefine2;
                                r3 = heapClassInst.heap32[r6 + numDefine13];
                                heapClassInst.heap32[r1 + numDefine13] = r3;
                            }
                            r1 = r2 >> numDefine2;
                            r2 = heapClassInst.heap32[r1 + numDefine2448];
                            if (!(r2 != r0)) {
                                r2 = heapClassInst.heap32[r6 + numDefine13];
                                heapClassInst.heap32[r1 + numDefine2448] = r2;
                            }
                            r2 = heapClassInst.heap32[r1 + numDefine2449];
                            r2 = (r2 + -1) | 0;
                            heapClassInst.heap32[r1 + numDefine2449] = r2;
                            heapClassInst.heap32[r6 + numDefine12] = 0;
                            r2 = heapClassInst.heap32[r1 + numDefine2450];
                            heapClassInst.heap32[r6 + numDefine13] = r2;
                            r2 = heapClassInst.heap32[r1 + numDefine2450];
                            if (!(r2 == 0)) {
                                r2 = r2 >> numDefine2;
                                heapClassInst.heap32[r2 + numDefine12] = r0;
                            }
                            heapClassInst.heap32[r1 + numDefine2450] = r0;
                            r0 = heapClassInst.heap32[r1 + numDefine2451];
                            r0 = (r0 + 1) | 0;
                            heapClassInst.heap32[r1 + numDefine2451] = r0;
                        } else {
                            break repeat1;
                        }
                    }
                } else {
                    r1 = (r0 + numDefine24) | 0;
                    r6 = r7 << numDefine2;
                    r7 = (r1 + r9) | 0;
                    r1 = (r1 + r6) | 0;
                    r6 = r7 >> numDefine2;
                    r1 = r1 >> numDefine2;
                    r6 = heapClassInst.heap32[r6];
                    r1 = heapClassInst.heap32[r1];
                    heapClassInst.heap32[g0] = r2;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = r6;
                    heapClassInst.heap32[g0 + numDefine3] = r3;
                    heapClassInst.heap32[g0 + numDefine4] = 0;
                    zn12gjkepa2Impl3EPA7newfaceEPNS3GJK3sSVES3S3B(i7);
                    r1 = commonVariable.rg0;
                    if (r1 == 0) {
                        break repeat1;
                    } else {
                        r2 = r1 >> numDefine2;
                        heapClassInst.heap8[r1 + numDefine56] = (byte) r4;
                        r3 = (r0 + r9) | 0;
                        r6 = (r0 + r4) | 0;
                        r7 = 0;
                        heapClassInst.heap32[r2 + numDefine9] = r0;
                        r0 = r3 >> numDefine2;
                        heapClassInst.heap8[r6 + numDefine56] = (byte) r7;
                        r3 = r5 >> numDefine2;
                        heapClassInst.heap32[r0 + numDefine9] = r1;
                        r0 = heapClassInst.heap32[r3];
                        if (r0 == 0) {
                            heapClassInst.heap32[r3 + 1] = r1;
                        } else {
                            r5 = numDefine2;
                            r6 = r0 >> numDefine2;
                            heapClassInst.heap8[r0 + numDefine57] = (byte) r5;
                            r5 = 1;
                            heapClassInst.heap32[r6 + numDefine10] = r1;
                            heapClassInst.heap8[r1 + numDefine58] = (byte) r5;
                            heapClassInst.heap32[r2 + numDefine11] = r0;
                        }
                        heapClassInst.heap32[r3] = r1;
                        r0 = heapClassInst.heap32[r3 + numDefine2];
                        r0 = (r0 + 1) | 0;
                        heapClassInst.heap32[r3 + numDefine2] = r0;
                    }
                }
                r0 = 1;
                commonVariable.rg0 = r0;
                return;
            }
        } while (false);
        r0 = 0;
        commonVariable.rg0 = r0;
        return;
    }

    public static void zn15btGjkEpaSolver211PenetrationEPK13btConvexShapeRK11btTransformS2S5RK9btVector3RNS8sResultsEb(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        int r20 = 0;
        int r21 = 0;
        int r22 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg10400;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp + numDefine5];
        r2 = heapClassInst.heap32[fp];
        r3 = heapClassInst.heap32[fp + numDefine2];
        r4 = heapClassInst.heap32[fp + numDefine3];
        r5 = sp + numDefineNeg176;
        r6 = heapClassInst.heap32[fp + numDefine6];
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r0;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        heapClassInst.heap32[g0 + numDefine3] = r4;
        heapClassInst.heap32[g0 + numDefine4] = r1;
        heapClassInst.heap32[g0 + numDefine5] = r5;
        heapClassInst.heap32[g0 + numDefine6] = r6;
        r2 = sp + numDefineNeg560;
        r3 = r2 >> numDefine2;
        zn12gjkepa2ConvexShapeRK11btTransform(i7);
        heapClassInst.heap32[r3 + numDefine32] = 0;
        heapClassInst.heap32[r3 + numDefine33] = 0;
        heapClassInst.heap32[r3 + numDefine34] = 0;
        heapClassInst.heap32[r3 + numDefine35] = 0;
        heapClassInst.heap32[r3 + numDefine91] = 0;
        heapClassInst.heap32[r3 + numDefine94] = numDefine2;
        r4 = heapClassInst.heap32[fp + numDefine4];
        heapClassInst.heap32[r3 + numDefine92] = 0;
        r4 = r4 >> numDefine2;
        heapClassInst.heap32[r3 + numDefine36] = 0;
        f0 = heapClassInst.heapFloat[r4 + numDefine2];
        f1 = heapClassInst.heapFloat[r4 + 1];
        f2 = heapClassInst.heapFloat[r4];
        r6 = sp + numDefineNeg48;
        f2 = -f2;
        r7 = r6 >> numDefine2;
        f1 = -f1;
        heapClassInst.heapFloat[fp + numDefineNeg12] = f2;
        f0 = -f0;
        heapClassInst.heapFloat[r7 + 1] = f1;
        heapClassInst.heapFloat[r7 + numDefine2] = f0;
        heapClassInst.heap32[r7 + numDefine3] = 0;
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r5;
        heapClassInst.heap32[g0 + numDefine2] = r6;
        zn12gjkepa2Impl3GJK8EvaluateERKNS13MinkowskiDiffERK9btVector3(i7);
        r6 = commonVariable.rg0;
        if (r6 == numDefine2) {
            r0 = r1 >> numDefine2;
            heapClassInst.heap32[r0] = numDefine2;
        } else {
            if (!(r6 != 1)) {
                r6 = sp + numDefineNeg10368;
                r7 = r6 >> numDefine2;
                heapClassInst.heap32[r7 + numDefine2448] = 0;
                heapClassInst.heap32[r7 + numDefine2449] = 0;
                heapClassInst.heap32[r7 + numDefine2450] = 0;
                heapClassInst.heap32[r7 + numDefine2451] = 0;
                heapClassInst.heap32[fp + numDefineNeg2592] = numDefine9;
                heapClassInst.heap32[r7 + numDefine10] = 0;
                heapClassInst.heap32[r7 + numDefine11] = 0;
                heapClassInst.heap32[r7 + numDefine12] = 0;
                heapClassInst.heap32[r7 + numDefine13] = 0;
                r8 = 0;
                r9 = (r6 + numDefine9780) | 0;
                r10 = (r6 + numDefine9728) | 0;
                heapClassInst.heap32[r7 + numDefine14] = 0;
                heapClassInst.heap32[r7 + numDefine2447] = 0;
                r11 = r8;
                r12 = r8;
                r13 = r8;
                repeat5: while (true) {
                    r14 = numDefine127;
                    r14 = (r14 - r13) | 0;
                    r15 = (r9 + r8) | 0;
                    r14 = (r14 * numDefine60) | 0;
                    r14 = (r6 + r14) | 0;
                    r15 = r15 >> numDefine2;
                    r14 = (r14 + numDefine2108) | 0;
                    r16 = (r10 + r8) | 0;
                    heapClassInst.heap32[r15 + -1] = 0;
                    heapClassInst.heap32[r15] = r12;
                    if (r12 != 0) {
                        r11 = r12 >> numDefine2;
                        heapClassInst.heap32[r11 + numDefine12] = r16;
                        r11 = heapClassInst.heap32[r7 + numDefine2451];
                    }
                    r8 = (r8 + numDefineNeg60) | 0;
                    r13 = (r13 + 1) | 0;
                    r11 = (r11 + 1) | 0;
                    heapClassInst.heap32[r7 + numDefine2450] = r16;
                    heapClassInst.heap32[r7 + numDefine2451] = r11;
                    r12 = r14;
                    if (!(r8 != numDefineNeg7680)) {
                        break repeat5;
                    }
                }
                r3 = heapClassInst.heap32[r3 + numDefine93];
                f0 = heapClassInst.heapFloat[r4 + numDefine2];
                f1 = heapClassInst.heapFloat[r4 + 1];
                f2 = heapClassInst.heapFloat[r4];
                r3 = r3 >> numDefine2;
                r4 = heapClassInst.heap32[r3 + numDefine8];
                if (uint(r4) < uint(numDefine2)) {
                    label = numDefine56;
                } else {
                    heapClassInst.heap32[g0] = r2;
                    zn12gjkepa2Impl3GJK13EncloseOriginEv(i7);
                    r4 = commonVariable.rg0;
                    if (r4 == 0) {
                        label = numDefine56;
                    } else {
                        r4 = heapClassInst.heap32[r7 + numDefine2448];
                        repeat14: do {
                            if (!(r4 == 0)) {
                                while (true) {
                                    r8 = r4 >> numDefine2;
                                    r9 = heapClassInst.heap32[r8 + numDefine13];
                                    if (!(r9 == 0)) {
                                        r9 = r9 >> numDefine2;
                                        r10 = heapClassInst.heap32[r8 + numDefine12];
                                        heapClassInst.heap32[r9 + numDefine12] = r10;
                                    }
                                    r9 = heapClassInst.heap32[r8 + numDefine12];
                                    if (!(r9 == 0)) {
                                        r9 = r9 >> numDefine2;
                                        r10 = heapClassInst.heap32[r8 + numDefine13];
                                        heapClassInst.heap32[r9 + numDefine13] = r10;
                                    }
                                    r9 = heapClassInst.heap32[r7 + numDefine2448];
                                    if (!(r9 != r4)) {
                                        r9 = heapClassInst.heap32[r8 + numDefine13];
                                        heapClassInst.heap32[r7 + numDefine2448] = r9;
                                    }
                                    r9 = heapClassInst.heap32[r7 + numDefine2449];
                                    r9 = (r9 + -1) | 0;
                                    heapClassInst.heap32[r7 + numDefine2449] = r9;
                                    heapClassInst.heap32[r8 + numDefine12] = 0;
                                    r9 = heapClassInst.heap32[r7 + numDefine2450];
                                    heapClassInst.heap32[r8 + numDefine13] = r9;
                                    r8 = heapClassInst.heap32[r7 + numDefine2450];
                                    if (!(r8 == 0)) {
                                        r8 = r8 >> numDefine2;
                                        heapClassInst.heap32[r8 + numDefine12] = r4;
                                    }
                                    heapClassInst.heap32[r7 + numDefine2450] = r4;
                                    r4 = heapClassInst.heap32[r7 + numDefine2451];
                                    r4 = (r4 + 1) | 0;
                                    heapClassInst.heap32[r7 + numDefine2451] = r4;
                                    r4 = heapClassInst.heap32[r7 + numDefine2448];
                                    if (!(r4 != 0)) {
                                        break repeat14;
                                    }
                                }
                            }
                        } while (false);
                        heapClassInst.heap32[fp + numDefineNeg2592] = 0;
                        heapClassInst.heap32[r7 + numDefine2447] = 0;
                        r4 = heapClassInst.heap32[r3 + 1];
                        r8 = heapClassInst.heap32[r3];
                        r9 = heapClassInst.heap32[r3 + numDefine3];
                        r10 = r8 >> numDefine2;
                        r11 = r4 >> numDefine2;
                        r9 = r9 >> numDefine2;
                        r12 = heapClassInst.heap32[r3 + numDefine2];
                        r13 = r12 >> numDefine2;
                        f3 = heapClassInst.heapFloat[r11 + numDefine6];
                        f4 = heapClassInst.heapFloat[r9 + numDefine6];
                        f5 = heapClassInst.heapFloat[r10 + numDefine6];
                        f6 = heapClassInst.heapFloat[r10 + numDefine5];
                        f7 = heapClassInst.heapFloat[r9 + numDefine5];
                        f8 = heapClassInst.heapFloat[r11 + numDefine4];
                        f9 = heapClassInst.heapFloat[r9 + numDefine4];
                        f10 = heapClassInst.heapFloat[r13 + numDefine5];
                        f11 = heapClassInst.heapFloat[r10 + numDefine4];
                        f12 = heapClassInst.heapFloat[r13 + numDefine4];
                        f3 = f3 - f4;
                        f6 = f6 - f7;
                        f8 = f8 - f9;
                        f5 = f5 - f4;
                        f11 = f11 - f9;
                        f13 = f6 * f3;
                        f9 = f12 - f9;
                        f12 = f5 * f8;
                        f10 = f10 - f7;
                        f3 = f11 * f3;
                        f14 = heapClassInst.heapFloat[r13 + numDefine6];
                        f15 = heapClassInst.heapFloat[r11 + numDefine5];
                        f13 = f13 * f9;
                        f12 = f12 * f10;
                        f7 = f15 - f7;
                        f12 = f13 + f12;
                        f3 = f3 * f10;
                        f6 = f6 * f8;
                        f4 = f14 - f4;
                        f8 = f11 * f7;
                        f3 = f12 - f3;
                        f6 = f6 * f4;
                        f5 = f5 * f7;
                        f3 = f3 - f6;
                        f4 = f8 * f4;
                        f3 = f3 + f4;
                        f4 = f5 * f9;
                        f3 = f3 - f4;
                        f4 = 0;
                        if (f3 < f4) {
                            heapClassInst.heap32[r3] = r4;
                            heapClassInst.heap32[r3 + 1] = r8;
                            f3 = heapClassInst.heapFloat[r3 + numDefine4];
                            heapClassInst.heap32[r3 + numDefine4] = heapClassInst.heap32[r3 + numDefine5];
                            heapClassInst.heapFloat[r3 + numDefine5] = f3;
                            r9 = r4;
                            r4 = r8;
                        } else {
                            r9 = r8;
                        }
                        heapClassInst.heap32[g0] = r6;
                        heapClassInst.heap32[g0 + 1] = r9;
                        heapClassInst.heap32[g0 + numDefine2] = r4;
                        heapClassInst.heap32[g0 + numDefine3] = r12;
                        heapClassInst.heap32[g0 + numDefine4] = 1;
                        zn12gjkepa2Impl3EPA7newfaceEPNS3GJK3sSVES3S3B(i7);
                        r4 = commonVariable.rg0;
                        r8 = heapClassInst.heap32[r3 + numDefine3];
                        r9 = heapClassInst.heap32[r3];
                        r10 = heapClassInst.heap32[r3 + 1];
                        heapClassInst.heap32[g0] = r6;
                        heapClassInst.heap32[g0 + 1] = r10;
                        heapClassInst.heap32[g0 + numDefine2] = r9;
                        heapClassInst.heap32[g0 + numDefine3] = r8;
                        heapClassInst.heap32[g0 + numDefine4] = 1;
                        zn12gjkepa2Impl3EPA7newfaceEPNS3GJK3sSVES3S3B(i7);
                        r8 = commonVariable.rg0;
                        r9 = heapClassInst.heap32[r3 + numDefine3];
                        r10 = heapClassInst.heap32[r3 + 1];
                        r11 = heapClassInst.heap32[r3 + numDefine2];
                        heapClassInst.heap32[g0] = r6;
                        heapClassInst.heap32[g0 + 1] = r11;
                        heapClassInst.heap32[g0 + numDefine2] = r10;
                        heapClassInst.heap32[g0 + numDefine3] = r9;
                        heapClassInst.heap32[g0 + numDefine4] = 1;
                        zn12gjkepa2Impl3EPA7newfaceEPNS3GJK3sSVES3S3B(i7);
                        r9 = commonVariable.rg0;
                        r10 = heapClassInst.heap32[r3 + numDefine3];
                        r11 = heapClassInst.heap32[r3 + numDefine2];
                        r12 = heapClassInst.heap32[r3];
                        heapClassInst.heap32[g0] = r6;
                        heapClassInst.heap32[g0 + 1] = r12;
                        heapClassInst.heap32[g0 + numDefine2] = r11;
                        heapClassInst.heap32[g0 + numDefine3] = r10;
                        heapClassInst.heap32[g0 + numDefine4] = 1;
                        zn12gjkepa2Impl3EPA7newfaceEPNS3GJK3sSVES3S3B(i7);
                        r10 = commonVariable.rg0;
                        r11 = heapClassInst.heap32[r7 + numDefine2449];
                        if (r11 != numDefine4) {
                            label = numDefine56;
                        } else {
                            r3 = heapClassInst.heap32[r7 + numDefine2448];
                            r11 = r3 >> numDefine2;
                            f0 = heapClassInst.heapFloat[r11 + numDefine4];
                            f0 = f0 * f0;
                            f1 = heapClassInst.heapFloat[r11 + numDefine5];
                            repeat35: while (true) {
                                f2 = f1;
                                r11 = r3;
                                f3 = f0;
                                while (true) {
                                    r3 = r3 >> numDefine2;
                                    r3 = heapClassInst.heap32[r3 + numDefine13];
                                    if (r3 != 0) {
                                        r12 = r3 >> numDefine2;
                                        f1 = heapClassInst.heapFloat[r12 + numDefine5];
                                        if (!(f1 < f2)) {
                                            f0 = heapClassInst.heapFloat[r12 + numDefine4];
                                            f0 = f0 * f0;
                                            if (!(f0 >= f3)) {
                                                continue repeat35;
                                            }
                                        }
                                    } else {
                                        break repeat35;
                                    }
                                }
                            }
                            r3 = r11 >> numDefine2;
                            f0 = heapClassInst.heapFloat[r3];
                            f1 = heapClassInst.heapFloat[r3 + 1];
                            f2 = heapClassInst.heapFloat[r3 + numDefine2];
                            f3 = heapClassInst.heapFloat[r3 + numDefine3];
                            f4 = heapClassInst.heapFloat[r3 + numDefine4];
                            f5 = heapClassInst.heapFloat[r3 + numDefine5];
                            r12 = heapClassInst.heap32[r3 + numDefine6];
                            r13 = heapClassInst.heap32[r3 + numDefine7];
                            r3 = heapClassInst.heap32[r3 + numDefine8];
                            r14 = 0;
                            r15 = r4 >> numDefine2;
                            heapClassInst.heap8[r4 + numDefine56] = (byte) r14;
                            heapClassInst.heap32[r15 + numDefine9] = r8;
                            r16 = r8 >> numDefine2;
                            heapClassInst.heap8[r8 + numDefine56] = (byte)  r14;
                            heapClassInst.heap32[r16 + numDefine9] = (byte) r4;
                            heapClassInst.heap8[r4 + numDefine57] = (byte) r14;
                            r17 = 1;
                            heapClassInst.heap32[r15 + numDefine10] = (byte) r9;
                            r18 = r9 >> numDefine2;
                            heapClassInst.heap8[r9 + numDefine56] = (byte) r17;
                            heapClassInst.heap32[r18 + numDefine9] = r4;
                            heapClassInst.heap8[r4 + numDefine58] = (byte) r14;
                            r19 = numDefine2;
                            heapClassInst.heap32[r15 + numDefine11] = r10;
                            r15 = r10 >> numDefine2;
                            heapClassInst.heap8[r10 + numDefine56] = (byte) r19;
                            heapClassInst.heap32[r15 + numDefine9] = (byte) r4;
                            heapClassInst.heap8[r8 + numDefine57] = (byte) r19;
                            heapClassInst.heap32[r16 + numDefine10] = (byte) r10;
                            heapClassInst.heap8[r10 + numDefine58] = (byte) r17;
                            heapClassInst.heap32[r15 + numDefine11] = (byte) r8;
                            heapClassInst.heap8[r8 + numDefine58] = (byte) r17;
                            heapClassInst.heap32[r16 + numDefine11] = (byte) r9;
                            heapClassInst.heap8[r9 + numDefine57] = (byte) r19;
                            heapClassInst.heap32[r18 + numDefine10] = (byte) r8;
                            heapClassInst.heap8[r9 + numDefine58] = (byte) r17;
                            heapClassInst.heap32[r18 + numDefine11] = r10;
                            heapClassInst.heap8[r10 + numDefine57] = (byte) r19;
                            heapClassInst.heap32[r15 + numDefine10] = r9;
                            heapClassInst.heap32[fp + numDefineNeg2592] = 0;
                            repeat42: while (true) {
                                r4 = (r14 + 1) | 0;
                                repeat44: while (true) {
                                    if (uint(r14) < uint(numDefine255)) {
                                        r8 = heapClassInst.heap32[r7 + numDefine2447];
                                        if (uint(r8) > uint(numDefine63)) {
                                            label = numDefine53;
                                            break repeat42;
                                        } else {
                                            r9 = sp + numDefineNeg16;
                                            r10 = r9 >> numDefine2;
                                            heapClassInst.heap32[fp + numDefineNeg4] = 0;
                                            heapClassInst.heap32[r10 + 1] = 0;
                                            r15 = (r8 + 1) | 0;
                                            heapClassInst.heap32[r10 + numDefine2] = 0;
                                            r8 = r8 << numDefine5;
                                            heapClassInst.heap32[r7 + numDefine2447] = r15;
                                            r8 = (r6 + r8) | 0;
                                            heapClassInst.heap8[r11 + numDefine59] = (byte) r4;
                                            r15 = (r8 + numDefine60) | 0;
                                            heapClassInst.heap32[g0] = r2;
                                            heapClassInst.heap32[g0 + 1] = r11;
                                            heapClassInst.heap32[g0 + numDefine2] = r15;
                                            r8 = r8 >> numDefine2;
                                            znk12gjkepa2Impl3GJK10getsupportERK9btVector3RNS03sSVE(i7);
                                            r16 = r11 >> numDefine2;
                                            f6 = heapClassInst.heapFloat[r16];
                                            f7 = heapClassInst.heapFloat[r8 + numDefine19];
                                            f8 = heapClassInst.heapFloat[r16 + 1];
                                            f9 = heapClassInst.heapFloat[r8 + numDefine20];
                                            f6 = f6 * f7;
                                            f7 = f8 * f9;
                                            f8 = heapClassInst.heapFloat[r16 + numDefine2];
                                            f9 = heapClassInst.heapFloat[r8 + numDefine21];
                                            f6 = f6 + f7;
                                            f7 = f8 * f9;
                                            f6 = f6 + f7;
                                            f7 = heapClassInst.heapFloat[r16 + numDefine4];
                                            f6 = f6 - f7;
                                            f7 = (float) numDefineFloat9165;
                                            if (f6 <= f7) {
                                                label = numDefine52;
                                                break repeat42;
                                            } else {
                                                r14 = (r14 + 1) | 0;
                                                r8 = (r11 + 1) | 0;
                                                r18 = 0;
                                                r20 = r17;
                                                repeat49: while (true) {
                                                    r21 = r18 << numDefine2;
                                                    r21 = (r11 + r21) | 0;
                                                    r22 = (r8 + r18) | 0;
                                                    r21 = r21 >> numDefine2;
                                                    r22 = heapClassInst.heapU8[r22 + numDefine55];
                                                    r21 = heapClassInst.heap32[r21 + numDefine9];
                                                    heapClassInst.heap32[g0] = r6;
                                                    heapClassInst.heap32[g0 + 1] = r14;
                                                    heapClassInst.heap32[g0 + numDefine2] = r15;
                                                    heapClassInst.heap32[g0 + numDefine3] = r21;
                                                    heapClassInst.heap32[g0 + numDefine4] = r22;
                                                    heapClassInst.heap32[g0 + numDefine5] = r9;
                                                    zn12gjkepa2Impl3EPA6expandEjPNS3GJK3sSVEPNS05sFaceEjRNS08sHorizonE(i7);
                                                    r18 = (r18 + 1) | 0;
                                                    r20 = commonVariable.rg0 & r20;
                                                    if (uint(r18) > uint(numDefine2)) {
                                                        break repeat49;
                                                    } else {
                                                        if (!(r20 != 0)) {
                                                            break repeat49;
                                                        }
                                                    }
                                                }
                                                if (r20 != 1) {
                                                    label = numDefine51;
                                                    break repeat42;
                                                } else {
                                                    r8 = heapClassInst.heap32[r10 + numDefine2];
                                                    if (uint(r8) < uint(numDefine3)) {
                                                        label = numDefine51;
                                                        break repeat42;
                                                    } else {
                                                        r8 = heapClassInst.heap32[fp + numDefineNeg4];
                                                        r9 = heapClassInst.heap32[r10 + 1];
                                                        r10 = r8 >> numDefine2;
                                                        heapClassInst.heap8[r8 + numDefine57] = (byte) r19;
                                                        r15 = 1;
                                                        heapClassInst.heap32[r10 + numDefine10] = r9;
                                                        r10 = r9 >> numDefine2;
                                                        heapClassInst.heap8[r9 + numDefine58] = (byte) r15;
                                                        heapClassInst.heap32[r10 + numDefine11] = r8;
                                                        r8 = heapClassInst.heap32[r16 + numDefine13];
                                                        if (!(r8 == 0)) {
                                                            r8 = r8 >> numDefine2;
                                                            r9 = heapClassInst.heap32[r16 + numDefine12];
                                                            heapClassInst.heap32[r8 + numDefine12] = r9;
                                                        }
                                                        r8 = heapClassInst.heap32[r16 + numDefine12];
                                                        if (!(r8 == 0)) {
                                                            r8 = r8 >> numDefine2;
                                                            r9 = heapClassInst.heap32[r16 + numDefine13];
                                                            heapClassInst.heap32[r8 + numDefine13] = r9;
                                                        }
                                                        r8 = heapClassInst.heap32[r7 + numDefine2448];
                                                        if (!(r8 != r11)) {
                                                            r8 = heapClassInst.heap32[r16 + numDefine13];
                                                            heapClassInst.heap32[r7 + numDefine2448] = r8;
                                                        }
                                                        r8 = heapClassInst.heap32[r7 + numDefine2449];
                                                        r8 = (r8 + -1) | 0;
                                                        heapClassInst.heap32[r7 + numDefine2449] = r8;
                                                        heapClassInst.heap32[r16 + numDefine12] = 0;
                                                        r8 = heapClassInst.heap32[r7 + numDefine2450];
                                                        heapClassInst.heap32[r16 + numDefine13] = r8;
                                                        r8 = heapClassInst.heap32[r7 + numDefine2450];
                                                        if (!(r8 == 0)) {
                                                            r8 = r8 >> numDefine2;
                                                            heapClassInst.heap32[r8 + numDefine12] = r11;
                                                        }
                                                        heapClassInst.heap32[r7 + numDefine2450] = r11;
                                                        r11 = heapClassInst.heap32[r7 + numDefine2451];
                                                        r11 = (r11 + 1) | 0;
                                                        heapClassInst.heap32[r7 + numDefine2451] = r11;
                                                        r8 = heapClassInst.heap32[r7 + numDefine2448];
                                                        r11 = r8 >> numDefine2;
                                                        f6 = heapClassInst.heapFloat[r11 + numDefine4];
                                                        f6 = f6 * f6;
                                                        f7 = heapClassInst.heapFloat[r11 + numDefine5];
                                                        repeat67: while (true) {
                                                            f8 = f7;
                                                            r11 = r8;
                                                            f9 = f6;
                                                            while (true) {
                                                                r8 = r8 >> numDefine2;
                                                                r8 = heapClassInst.heap32[r8 + numDefine13];
                                                                if (r8 != 0) {
                                                                    r9 = r8 >> numDefine2;
                                                                    f7 = heapClassInst.heapFloat[r9 + numDefine5];
                                                                    if (!(f7 < f8)) {
                                                                        f6 = heapClassInst.heapFloat[r9 + numDefine4];
                                                                        f6 = f6 * f6;
                                                                        if (!(f6 >= f9)) {
                                                                            continue repeat67;
                                                                        }
                                                                    }
                                                                } else {
                                                                    break repeat67;
                                                                }
                                                            }
                                                        }
                                                        r8 = r11 >> numDefine2;
                                                        f6 = heapClassInst.heapFloat[r8 + numDefine5];
                                                        r4 = (r4 + 1) | 0;
                                                        if (!(f6 < f5)) {
                                                            break repeat44;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    } else {
                                        label = numDefine55;
                                        break repeat42;
                                    }
                                }
                                f0 = heapClassInst.heapFloat[r8];
                                f1 = heapClassInst.heapFloat[r8 + 1];
                                f2 = heapClassInst.heapFloat[r8 + numDefine2];
                                f3 = heapClassInst.heapFloat[r8 + numDefine3];
                                f4 = heapClassInst.heapFloat[r8 + numDefine4];
                                r12 = heapClassInst.heap32[r8 + numDefine6];
                                r13 = heapClassInst.heap32[r8 + numDefine7];
                                r3 = heapClassInst.heap32[r8 + numDefine8];
                                f5 = f6;
                            }
                            switch (label) {
                                case numDefine53:
                                    heapClassInst.heap32[fp + numDefineNeg2592] = numDefine6;
                                    break;
                                case numDefine52:
                                    heapClassInst.heap32[fp + numDefineNeg2592] = numDefine7;
                                    break;
                                case numDefine51:
                                    heapClassInst.heap32[fp + numDefineNeg2592] = numDefine4;
                                    break;
                                default:
                                    break;
                            }
                            heapClassInst.heapFloat[r7 + numDefine10] = f0;
                            heapClassInst.heapFloat[r7 + numDefine11] = f1;
                            heapClassInst.heapFloat[r7 + numDefine12] = f2;
                            heapClassInst.heapFloat[r7 + numDefine13] = f3;
                            heapClassInst.heapFloat[r7 + numDefine14] = f4;
                            heapClassInst.heap32[r7 + numDefine9] = numDefine3;
                            heapClassInst.heap32[r7 + 1] = r12;
                            heapClassInst.heap32[r7 + numDefine2] = r13;
                            heapClassInst.heap32[r7 + numDefine3] = r3;
                            r3 = r3 >> numDefine2;
                            r2 = r13 >> numDefine2;
                            f2 = f2 * f4;
                            f3 = heapClassInst.heapFloat[r3 + numDefine6];
                            f5 = heapClassInst.heapFloat[r2 + numDefine6];
                            f1 = f1 * f4;
                            f6 = heapClassInst.heapFloat[r3 + numDefine5];
                            f7 = heapClassInst.heapFloat[r2 + numDefine5];
                            f0 = f0 * f4;
                            f4 = heapClassInst.heapFloat[r3 + numDefine4];
                            f8 = heapClassInst.heapFloat[r2 + numDefine4];
                            f5 = f5 - f2;
                            f6 = f6 - f1;
                            f8 = f8 - f0;
                            f3 = f3 - f2;
                            f7 = f7 - f1;
                            f4 = f4 - f0;
                            f9 = f7 * f3;
                            f10 = f5 * f6;
                            f5 = f5 * f4;
                            f3 = f8 * f3;
                            f9 = f9 - f10;
                            f3 = f5 - f3;
                            f5 = f8 * f6;
                            f4 = f7 * f4;
                            f4 = f5 - f4;
                            f5 = f9 * f9;
                            f3 = f3 * f3;
                            f3 = f5 + f3;
                            f4 = f4 * f4;
                            f3 = f3 + f4;
                            heapClassInst.heapFloat[g0] = f3;
                            sqrtf(i7);
                            heapClassInst.heapFloat[r7 + numDefine5] = (float) commonVariable.fg0;
                            r4 = r12 >> numDefine2;
                            f3 = heapClassInst.heapFloat[r4 + numDefine6];
                            f4 = heapClassInst.heapFloat[r4 + numDefine5];
                            f5 = heapClassInst.heapFloat[r4 + numDefine4];
                            f6 = heapClassInst.heapFloat[r3 + numDefine6];
                            f7 = heapClassInst.heapFloat[r3 + numDefine5];
                            f8 = heapClassInst.heapFloat[r3 + numDefine4];
                            f6 = f6 - f2;
                            f4 = f4 - f1;
                            f8 = f8 - f0;
                            f3 = f3 - f2;
                            f7 = f7 - f1;
                            f5 = f5 - f0;
                            f9 = f7 * f3;
                            f10 = f6 * f4;
                            f6 = f6 * f5;
                            f3 = f8 * f3;
                            f9 = f9 - f10;
                            f3 = f6 - f3;
                            f4 = f8 * f4;
                            f5 = f7 * f5;
                            f4 = f4 - f5;
                            f5 = f9 * f9;
                            f3 = f3 * f3;
                            f3 = f5 + f3;
                            f4 = f4 * f4;
                            f3 = f3 + f4;
                            heapClassInst.heapFloat[g0] = f3;
                            sqrtf(i7);
                            heapClassInst.heapFloat[r7 + numDefine6] = (float) commonVariable.fg0;
                            f3 = heapClassInst.heapFloat[r2 + numDefine6];
                            f4 = heapClassInst.heapFloat[r2 + numDefine5];
                            f5 = heapClassInst.heapFloat[r2 + numDefine4];
                            f6 = heapClassInst.heapFloat[r4 + numDefine6];
                            f7 = heapClassInst.heapFloat[r4 + numDefine5];
                            f8 = heapClassInst.heapFloat[r4 + numDefine4];
                            f6 = f6 - f2;
                            f4 = f4 - f1;
                            f8 = f8 - f0;
                            f2 = f3 - f2;
                            f1 = f7 - f1;
                            f0 = f5 - f0;
                            f3 = f1 * f2;
                            f5 = f6 * f4;
                            f6 = f6 * f0;
                            f2 = f8 * f2;
                            f3 = f3 - f5;
                            f2 = f6 - f2;
                            f4 = f8 * f4;
                            f0 = f1 * f0;
                            f0 = f4 - f0;
                            f1 = f3 * f3;
                            f2 = f2 * f2;
                            f1 = f1 + f2;
                            f0 = f0 * f0;
                            f0 = f1 + f0;
                            heapClassInst.heapFloat[g0] = f0;
                            sqrtf(i7);
                            f1 = heapClassInst.heapFloat[r7 + numDefine5];
                            f2 = heapClassInst.heapFloat[r7 + numDefine6];
                            f3 = f1 + f2;
                            f3 = (float) (f3 + commonVariable.fg0);
                            f1 = f1 / f3;
                            f2 = f2 / f3;
                            heapClassInst.heapFloat[r7 + numDefine5] = f1;
                            f0 = (float) (commonVariable.fg0 / f3);
                            heapClassInst.heapFloat[r7 + numDefine6] = f2;
                            heapClassInst.heapFloat[r7 + numDefine7] = f0;
                            label = numDefine60;
                        }
                    }
                }
                if (label == numDefine56) {
                    heapClassInst.heap32[fp + numDefineNeg2592] = numDefine8;
                    heapClassInst.heapFloat[r7 + numDefine10] = f2;
                    heapClassInst.heapFloat[r7 + numDefine11] = f1;
                    heapClassInst.heapFloat[r7 + numDefine12] = f0;
                    f2 = f2 * f2;
                    f1 = f1 * f1;
                    heapClassInst.heap32[r7 + numDefine13] = 0;
                    f1 = f2 + f1;
                    f0 = f0 * f0;
                    f0 = f1 + f0;
                    heapClassInst.heapFloat[g0] = f0;
                    sqrtf(i7);
                    f0 = (float) commonVariable.fg0;
                    f1 = 0;
                    if (f0 > f1) {
                        f1 = 1;
                        f2 = heapClassInst.heapFloat[r7 + numDefine12];
                        f0 = f1 / f0;
                        f1 = heapClassInst.heapFloat[r7 + numDefine11];
                        f3 = heapClassInst.heapFloat[r7 + numDefine10];
                        f2 = f2 * f0;
                        f1 = f1 * f0;
                        f0 = f3 * f0;
                    } else {
                        f0 = 1;
                        f2 = f1;
                    }
                    heapClassInst.heapFloat[r7 + numDefine10] = f0;
                    heapClassInst.heapFloat[r7 + numDefine11] = f1;
                    heapClassInst.heapFloat[r7 + numDefine12] = f2;
                    heapClassInst.heap32[r7 + numDefine13] = 0;
                    heapClassInst.heap32[r7 + numDefine14] = 0;
                    heapClassInst.heap32[r7 + numDefine9] = 1;
                    r2 = heapClassInst.heap32[r3];
                    heapClassInst.heap32[r7 + 1] = r2;
                    heapClassInst.heap32[r7 + numDefine5] = numDefine53216;
                }
                r2 = heapClassInst.heap32[fp + numDefineNeg2592];
                if (r2 == numDefine9) {
                    r1 = r1 >> numDefine2;
                    heapClassInst.heap32[r1] = numDefine3;
                    r1 = 0;
                    commonVariable.rg0 = r1;
                    return;
                } else {
                    r2 = heapClassInst.heap32[r7 + numDefine9];
                    repeat90: do {
                        if (r2 != 0) {
                            r2 = 0;
                            f0 = 0;
                            f1 = f0;
                            f2 = f0;
                            while (true) {
                                r3 = r2 << numDefine2;
                                r3 = (r6 + r3) | 0;
                                r4 = r5 >> numDefine2;
                                r3 = r3 >> numDefine2;
                                r8 = heapClassInst.heap32[r4 + numDefine30];
                                r2 = (r2 + 1) | 0;
                                r9 = heapClassInst.heap32[r3 + 1];
                                r10 = heapClassInst.heap32[fp + numDefineNeg44];
                                r4 = heapClassInst.heap32[r4 + numDefine31];
                                r11 = r8 & 1;
                                if (r11 != 0) {
                                    r11 = (r10 + r4) | 0;
                                    r11 = r11 >> numDefine2;
                                    r11 = heapClassInst.heap32[r11];
                                    r8 = (r8 + r11) | 0;
                                    r8 = (r8 + -1) | 0;
                                    r8 = r8 >> numDefine2;
                                    r8 = heapClassInst.heap32[r8];
                                }
                                r11 = sp + numDefineNeg32;
                                r4 = (r10 + r4) | 0;
                                heapClassInst.heap32[g0] = r11;
                                heapClassInst.heap32[g0 + 1] = r4;
                                heapClassInst.heap32[g0 + numDefine2] = r9;
                                functionTable.get(r8 >> numDefine2).accept(i7);
                                r4 = r11 >> numDefine2;
                                f3 = heapClassInst.heapFloat[fp + numDefineNeg8];
                                f4 = heapClassInst.heapFloat[r3 + numDefine5];
                                f5 = heapClassInst.heapFloat[r4 + 1];
                                f6 = heapClassInst.heapFloat[r4 + numDefine2];
                                f3 = f3 * f4;
                                f5 = f5 * f4;
                                f4 = f6 * f4;
                                f2 = f2 + f3;
                                f1 = f1 + f5;
                                f0 = f0 + f4;
                                r3 = heapClassInst.heap32[r7 + numDefine9];
                                if (!(uint(r3) > uint(r2))) {
                                    break repeat90;
                                }
                            }
                        } else {
                            f0 = 0;
                            f1 = f0;
                            f2 = f0;
                        }
                    } while (false);
                    r1 = r1 >> numDefine2;
                    r0 = r0 >> numDefine2;
                    heapClassInst.heap32[r1] = 1;
                    f3 = heapClassInst.heapFloat[r0];
                    f4 = heapClassInst.heapFloat[r0 + 1];
                    f5 = heapClassInst.heapFloat[r0 + numDefine4];
                    f6 = heapClassInst.heapFloat[r0 + numDefine5];
                    f3 = f3 * f2;
                    f4 = f4 * f1;
                    f7 = heapClassInst.heapFloat[r0 + numDefine2];
                    f8 = heapClassInst.heapFloat[r0 + numDefine8];
                    f9 = heapClassInst.heapFloat[r0 + numDefine9];
                    f10 = heapClassInst.heapFloat[r0 + numDefine6];
                    f5 = f5 * f2;
                    f6 = f6 * f1;
                    f3 = f3 + f4;
                    f4 = f7 * f0;
                    f7 = heapClassInst.heapFloat[r0 + numDefine10];
                    f8 = f8 * f2;
                    f9 = f9 * f1;
                    f5 = f5 + f6;
                    f6 = f10 * f0;
                    f3 = f3 + f4;
                    f4 = heapClassInst.heapFloat[r0 + numDefine12];
                    f10 = heapClassInst.heapFloat[r0 + numDefine14];
                    f11 = heapClassInst.heapFloat[r0 + numDefine13];
                    f5 = f5 + f6;
                    f6 = f8 + f9;
                    f7 = f7 * f0;
                    f3 = f3 + f4;
                    f4 = f6 + f7;
                    f5 = f5 + f11;
                    heapClassInst.heapFloat[r1 + 1] = f3;
                    f3 = f4 + f10;
                    heapClassInst.heapFloat[r1 + numDefine2] = f5;
                    heapClassInst.heapFloat[r1 + numDefine3] = f3;
                    heapClassInst.heap32[r1 + numDefine4] = 0;
                    f3 = heapClassInst.heapFloat[r7 + numDefine14];
                    f4 = heapClassInst.heapFloat[r7 + numDefine11];
                    f5 = heapClassInst.heapFloat[r7 + numDefine10];
                    f6 = heapClassInst.heapFloat[r7 + numDefine12];
                    f7 = f5 * f3;
                    f8 = f4 * f3;
                    f9 = f6 * f3;
                    f2 = f2 - f7;
                    f7 = heapClassInst.heapFloat[r0];
                    f1 = f1 - f8;
                    f8 = heapClassInst.heapFloat[r0 + 1];
                    f10 = heapClassInst.heapFloat[r0 + numDefine4];
                    f11 = heapClassInst.heapFloat[r0 + numDefine5];
                    f7 = f7 * f2;
                    f8 = f8 * f1;
                    f0 = f0 - f9;
                    f9 = heapClassInst.heapFloat[r0 + numDefine2];
                    f12 = heapClassInst.heapFloat[r0 + numDefine8];
                    f13 = heapClassInst.heapFloat[r0 + numDefine9];
                    f14 = heapClassInst.heapFloat[r0 + numDefine6];
                    f10 = f10 * f2;
                    f11 = f11 * f1;
                    f7 = f7 + f8;
                    f8 = f9 * f0;
                    f9 = heapClassInst.heapFloat[r0 + numDefine10];
                    f2 = f12 * f2;
                    f1 = f13 * f1;
                    f10 = f10 + f11;
                    f11 = f14 * f0;
                    f7 = f7 + f8;
                    f8 = heapClassInst.heapFloat[r0 + numDefine12];
                    f12 = heapClassInst.heapFloat[r0 + numDefine14];
                    f13 = heapClassInst.heapFloat[r0 + numDefine13];
                    f10 = f10 + f11;
                    f1 = f2 + f1;
                    f0 = f9 * f0;
                    f2 = f7 + f8;
                    f0 = f1 + f0;
                    f1 = f10 + f13;
                    heapClassInst.heapFloat[r1 + numDefine5] = f2;
                    f0 = f0 + f12;
                    heapClassInst.heapFloat[r1 + numDefine6] = f1;
                    heapClassInst.heapFloat[r1 + numDefine7] = f0;
                    f0 = -f5;
                    heapClassInst.heap32[r1 + numDefine8] = 0;
                    f1 = -f4;
                    heapClassInst.heapFloat[r1 + numDefine9] = f0;
                    f0 = -f6;
                    heapClassInst.heapFloat[r1 + numDefine10] = f1;
                    heapClassInst.heapFloat[r1 + numDefine11] = f0;
                    f0 = -f3;
                    heapClassInst.heap32[r1 + numDefine12] = 0;
                    heapClassInst.heapFloat[r1 + numDefine13] = f0;
                    r1 = 1;
                    commonVariable.rg0 = r1;
                    return;
                }
            }
        }
        r0 = 0;
        commonVariable.rg0 = r0;
        return;
    }

    public static void zn15btGjkEpaSolver28DistanceEPK13btConvexShapeRK11btTransformS2S5RK9btVector3RNS8sResultsE(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg592;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp + numDefine5];
        r2 = heapClassInst.heap32[fp];
        r3 = heapClassInst.heap32[fp + numDefine2];
        r4 = heapClassInst.heap32[fp + numDefine3];
        r5 = sp + numDefineNeg176;
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r0;
        heapClassInst.heap32[g0 + numDefine2] = r3;
        heapClassInst.heap32[g0 + numDefine3] = r4;
        heapClassInst.heap32[g0 + numDefine4] = r1;
        heapClassInst.heap32[g0 + numDefine5] = r5;
        heapClassInst.heap32[g0 + numDefine6] = 0;
        r2 = sp + numDefineNeg560;
        r3 = r2 >> numDefine2;
        zn12gjkepa2ConvexShapeRK11btTransform(i7);
        heapClassInst.heap32[r3 + numDefine32] = 0;
        heapClassInst.heap32[r3 + numDefine33] = 0;
        heapClassInst.heap32[r3 + numDefine34] = 0;
        heapClassInst.heap32[r3 + numDefine35] = 0;
        heapClassInst.heap32[r3 + numDefine91] = 0;
        heapClassInst.heap32[r3 + numDefine94] = numDefine2;
        heapClassInst.heap32[r3 + numDefine92] = 0;
        heapClassInst.heap32[r3 + numDefine36] = 0;
        r4 = heapClassInst.heap32[fp + numDefine4];
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r5;
        heapClassInst.heap32[g0 + numDefine2] = r4;
        zn12gjkepa2Impl3GJK8EvaluateERKNS13MinkowskiDiffERK9btVector3(i7);
        r2 = commonVariable.rg0;
        if (r2 == 0) {
            r2 = heapClassInst.heap32[r3 + numDefine93];
            r4 = r2 >> numDefine2;
            r4 = heapClassInst.heap32[r4 + numDefine8];
            repeat3: do {
                if (r4 != 0) {
                    r4 = 0;
                    f0 = 0;
                    f1 = f0;
                    f2 = f0;
                    f3 = f0;
                    f4 = f0;
                    f5 = f0;
                    while (true) {
                        r6 = r4 << numDefine2;
                        r2 = (r2 + r6) | 0;
                        r2 = r2 >> numDefine2;
                        r7 = r5 >> numDefine2;
                        r8 = heapClassInst.heap32[r7 + numDefine30];
                        r4 = (r4 + 1) | 0;
                        f6 = heapClassInst.heapFloat[r2 + numDefine4];
                        r2 = heapClassInst.heap32[r2];
                        r9 = heapClassInst.heap32[fp + numDefineNeg44];
                        r10 = heapClassInst.heap32[r7 + numDefine31];
                        r11 = r8 & 1;
                        if (r11 != 0) {
                            r11 = (r9 + r10) | 0;
                            r11 = r11 >> numDefine2;
                            r11 = heapClassInst.heap32[r11];
                            r8 = (r8 + r11) | 0;
                            r8 = (r8 + -1) | 0;
                            r8 = r8 >> numDefine2;
                            r8 = heapClassInst.heap32[r8];
                        }
                        r11 = sp + numDefineNeg48;
                        r9 = (r9 + r10) | 0;
                        heapClassInst.heap32[g0] = r11;
                        heapClassInst.heap32[g0 + 1] = r9;
                        heapClassInst.heap32[g0 + numDefine2] = r2;
                        functionTable.get(r8 >> numDefine2).accept(i7);
                        r2 = heapClassInst.heap32[r3 + numDefine93];
                        r2 = (r2 + r6) | 0;
                        r2 = r2 >> numDefine2;
                        r6 = r11 >> numDefine2;
                        r2 = heapClassInst.heap32[r2];
                        r2 = r2 >> numDefine2;
                        f7 = heapClassInst.heapFloat[fp + numDefineNeg12];
                        f8 = heapClassInst.heapFloat[r6 + 1];
                        f9 = heapClassInst.heapFloat[r6 + numDefine2];
                        f10 = heapClassInst.heapFloat[r2 + numDefine2];
                        f11 = heapClassInst.heapFloat[r2 + 1];
                        f12 = heapClassInst.heapFloat[r2];
                        f7 = f7 * f6;
                        f8 = f8 * f6;
                        f9 = f9 * f6;
                        r2 = heapClassInst.heap32[r7 + numDefine30];
                        f5 = f5 + f7;
                        f4 = f4 + f8;
                        f3 = f3 + f9;
                        f7 = -f10;
                        f8 = -f11;
                        f9 = -f12;
                        r6 = heapClassInst.heap32[r7 + 1];
                        r8 = heapClassInst.heap32[r7 + numDefine31];
                        r9 = r2 & 1;
                        if (r9 != 0) {
                            r9 = (r6 + r8) | 0;
                            r9 = r9 >> numDefine2;
                            r9 = heapClassInst.heap32[r9];
                            r2 = (r2 + r9) | 0;
                            r2 = (r2 + -1) | 0;
                            r2 = r2 >> numDefine2;
                            r2 = heapClassInst.heap32[r2];
                        }
                        f10 = heapClassInst.heapFloat[r7 + numDefine2];
                        f11 = heapClassInst.heapFloat[r7 + numDefine3];
                        f12 = heapClassInst.heapFloat[r7 + numDefine6];
                        f13 = heapClassInst.heapFloat[r7 + numDefine7];
                        f10 = f10 * f9;
                        f11 = f11 * f8;
                        f14 = heapClassInst.heapFloat[r7 + numDefine4];
                        f15 = heapClassInst.heapFloat[r7 + numDefine10];
                        f16 = heapClassInst.heapFloat[r7 + numDefine11];
                        f17 = heapClassInst.heapFloat[r7 + numDefine12];
                        f18 = heapClassInst.heapFloat[r7 + numDefine8];
                        f12 = f12 * f9;
                        f13 = f13 * f8;
                        f10 = f10 + f11;
                        f11 = f14 * f7;
                        r9 = sp + numDefineNeg16;
                        f9 = f15 * f9;
                        f8 = f16 * f8;
                        f12 = f12 + f13;
                        f13 = f18 * f7;
                        f10 = f10 + f11;
                        r10 = r9 >> numDefine2;
                        f8 = f9 + f8;
                        f7 = f17 * f7;
                        f9 = f12 + f13;
                        heapClassInst.heapFloat[fp + numDefineNeg4] = f10;
                        f7 = f8 + f7;
                        heapClassInst.heapFloat[r10 + 1] = f9;
                        heapClassInst.heapFloat[r10 + numDefine2] = f7;
                        heapClassInst.heap32[r10 + numDefine3] = 0;
                        r10 = sp + numDefineNeg32;
                        r6 = (r6 + r8) | 0;
                        heapClassInst.heap32[g0] = r10;
                        heapClassInst.heap32[g0 + 1] = r6;
                        heapClassInst.heap32[g0 + numDefine2] = r9;
                        functionTable.get(r2 >> numDefine2).accept(i7);
                        r2 = r10 >> numDefine2;
                        f7 = heapClassInst.heapFloat[r7 + numDefine14];
                        f8 = heapClassInst.heapFloat[fp + numDefineNeg8];
                        f9 = heapClassInst.heapFloat[r7 + numDefine18];
                        f10 = heapClassInst.heapFloat[r7 + numDefine22];
                        f11 = heapClassInst.heapFloat[r7 + numDefine15];
                        f12 = heapClassInst.heapFloat[r2 + 1];
                        f13 = heapClassInst.heapFloat[r7 + numDefine19];
                        f14 = heapClassInst.heapFloat[r7 + numDefine23];
                        f7 = f7 * f8;
                        f11 = f11 * f12;
                        f15 = heapClassInst.heapFloat[r7 + numDefine16];
                        f16 = heapClassInst.heapFloat[r2 + numDefine2];
                        f17 = heapClassInst.heapFloat[r7 + numDefine20];
                        f18 = heapClassInst.heapFloat[r7 + numDefine24];
                        f9 = f9 * f8;
                        f13 = f13 * f12;
                        f8 = f10 * f8;
                        f10 = f14 * f12;
                        f7 = f7 + f11;
                        f11 = f15 * f16;
                        f9 = f9 + f13;
                        f12 = f17 * f16;
                        f8 = f8 + f10;
                        f10 = f18 * f16;
                        f7 = f7 + f11;
                        f11 = heapClassInst.heapFloat[r7 + numDefine26];
                        f9 = f9 + f12;
                        f12 = heapClassInst.heapFloat[r7 + numDefine27];
                        f8 = f8 + f10;
                        f10 = heapClassInst.heapFloat[r7 + numDefine28];
                        f7 = f7 + f11;
                        f9 = f9 + f12;
                        f8 = f8 + f10;
                        f7 = f7 * f6;
                        f9 = f9 * f6;
                        f6 = f8 * f6;
                        r2 = heapClassInst.heap32[r3 + numDefine93];
                        f2 = f2 + f7;
                        f1 = f1 + f9;
                        f0 = f0 + f6;
                        r6 = r2 >> numDefine2;
                        r6 = heapClassInst.heap32[r6 + numDefine8];
                        if (!(uint(r6) > uint(r4))) {
                            break repeat3;
                        }
                    }
                } else {
                    f0 = 0;
                    f1 = f0;
                    f2 = f0;
                    f3 = f0;
                    f4 = f0;
                    f5 = f0;
                }
            } while (false);
            r0 = r0 >> numDefine2;
            f6 = heapClassInst.heapFloat[r0];
            f7 = heapClassInst.heapFloat[r0 + 1];
            f8 = heapClassInst.heapFloat[r0 + numDefine4];
            f9 = heapClassInst.heapFloat[r0 + numDefine5];
            f6 = f6 * f5;
            f7 = f7 * f4;
            f10 = heapClassInst.heapFloat[r0 + numDefine2];
            f11 = heapClassInst.heapFloat[r0 + numDefine8];
            f12 = heapClassInst.heapFloat[r0 + numDefine9];
            f13 = heapClassInst.heapFloat[r0 + numDefine6];
            f8 = f8 * f5;
            f9 = f9 * f4;
            f6 = f6 + f7;
            f7 = f10 * f3;
            f10 = heapClassInst.heapFloat[r0 + numDefine10];
            f11 = f11 * f5;
            f12 = f12 * f4;
            f8 = f8 + f9;
            f9 = f13 * f3;
            f6 = f6 + f7;
            f7 = heapClassInst.heapFloat[r0 + numDefine12];
            f13 = heapClassInst.heapFloat[r0 + numDefine14];
            f14 = heapClassInst.heapFloat[r0 + numDefine13];
            f8 = f8 + f9;
            r1 = r1 >> numDefine2;
            f9 = f11 + f12;
            f10 = f10 * f3;
            f6 = f6 + f7;
            f7 = f9 + f10;
            f8 = f8 + f14;
            heapClassInst.heapFloat[r1 + 1] = f6;
            f6 = f7 + f13;
            heapClassInst.heapFloat[r1 + numDefine2] = f8;
            heapClassInst.heapFloat[r1 + numDefine3] = f6;
            heapClassInst.heap32[r1 + numDefine4] = 0;
            f6 = heapClassInst.heapFloat[r0];
            f7 = heapClassInst.heapFloat[r0 + 1];
            f8 = heapClassInst.heapFloat[r0 + numDefine4];
            f9 = heapClassInst.heapFloat[r0 + numDefine5];
            f10 = heapClassInst.heapFloat[r0 + numDefine2];
            f6 = f6 * f2;
            f7 = f7 * f1;
            f11 = heapClassInst.heapFloat[r0 + numDefine8];
            f12 = heapClassInst.heapFloat[r0 + numDefine9];
            f13 = heapClassInst.heapFloat[r0 + numDefine6];
            f8 = f8 * f2;
            f9 = f9 * f1;
            f6 = f6 + f7;
            f7 = f10 * f0;
            f10 = heapClassInst.heapFloat[r0 + numDefine10];
            f11 = f11 * f2;
            f12 = f12 * f1;
            f8 = f8 + f9;
            f9 = f13 * f0;
            f6 = f6 + f7;
            f7 = heapClassInst.heapFloat[r0 + numDefine12];
            f13 = heapClassInst.heapFloat[r0 + numDefine14];
            f14 = heapClassInst.heapFloat[r0 + numDefine13];
            f8 = f8 + f9;
            f9 = f11 + f12;
            f10 = f10 * f0;
            f6 = f6 + f7;
            f7 = f9 + f10;
            f8 = f8 + f14;
            heapClassInst.heapFloat[r1 + numDefine5] = f6;
            f6 = f7 + f13;
            heapClassInst.heapFloat[r1 + numDefine6] = f8;
            heapClassInst.heapFloat[r1 + numDefine7] = f6;
            f2 = f5 - f2;
            heapClassInst.heap32[r1 + numDefine8] = 0;
            f1 = f4 - f1;
            heapClassInst.heapFloat[r1 + numDefine9] = f2;
            f0 = f3 - f0;
            heapClassInst.heapFloat[r1 + numDefine10] = f1;
            heapClassInst.heapFloat[r1 + numDefine11] = f0;
            f2 = f2 * f2;
            f1 = f1 * f1;
            heapClassInst.heap32[r1 + numDefine12] = 0;
            f1 = f2 + f1;
            f0 = f0 * f0;
            f0 = f1 + f0;
            heapClassInst.heapFloat[g0] = f0;
            sqrtf(i7);
            f1 = 1;
            f2 = (float) numDefineFloat9165;
            f2 = commonVariable.fg0 > f2 ? (float) commonVariable.fg0 : f1;
            heapClassInst.heapFloat[r1 + numDefine13] = (float) commonVariable.fg0;
            f0 = f1 / f2;
            f1 = heapClassInst.heapFloat[r1 + numDefine9];
            f1 = f1 * f0;
            heapClassInst.heapFloat[r1 + numDefine9] = f1;
            f1 = heapClassInst.heapFloat[r1 + numDefine10];
            f1 = f1 * f0;
            heapClassInst.heapFloat[r1 + numDefine10] = f1;
            f1 = heapClassInst.heapFloat[r1 + numDefine11];
            f0 = f1 * f0;
            heapClassInst.heapFloat[r1 + numDefine11] = f0;
            r0 = 1;
            commonVariable.rg0 = r0;
            return;
        } else {
            if (r2 != 1) {
                r0 = numDefine2;
            } else {
                r0 = 1;
            }
            r1 = r1 >> numDefine2;
            heapClassInst.heap32[r1] = r0;
            r0 = 0;
            commonVariable.rg0 = r0;
            return;
        }
    }

    public static void zn30btGjk(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg104;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine4];
        r1 = heapClassInst.heap32[fp + numDefine5];
        r2 = r0 >> numDefine2;
        r3 = r1 >> numDefine2;
        f0 = heapClassInst.heapFloat[r2 + numDefine14];
        f1 = heapClassInst.heapFloat[r3 + numDefine14];
        f2 = heapClassInst.heapFloat[r2 + numDefine13];
        f3 = heapClassInst.heapFloat[r3 + numDefine13];
        f4 = heapClassInst.heapFloat[r2 + numDefine12];
        f5 = heapClassInst.heapFloat[r3 + numDefine12];
        r2 = sp + numDefineNeg16;
        f4 = f4 - f5;
        r3 = r2 >> numDefine2;
        f2 = f2 - f3;
        heapClassInst.heapFloat[fp + numDefineNeg4] = f4;
        f0 = f0 - f1;
        heapClassInst.heapFloat[r3 + 1] = f2;
        heapClassInst.heapFloat[r3 + numDefine2] = f0;
        heapClassInst.heap32[r3 + numDefine3] = 0;
        r3 = heapClassInst.heap32[fp + numDefine2];
        r4 = heapClassInst.heap32[fp + numDefine3];
        r5 = sp + numDefineNeg72;
        heapClassInst.heap32[g0] = r3;
        heapClassInst.heap32[g0 + 1] = r0;
        heapClassInst.heap32[g0 + numDefine2] = r4;
        heapClassInst.heap32[g0 + numDefine3] = r1;
        heapClassInst.heap32[g0 + numDefine4] = r2;
        heapClassInst.heap32[g0 + numDefine5] = r5;
        heapClassInst.heap32[g0 + numDefine6] = 1;
        r6 = heapClassInst.heap32[fp + numDefine6];
        r7 = heapClassInst.heap32[fp + numDefine7];
        r8 = heapClassInst.heap32[fp + numDefine8];
        zn15btGjkEpaSolver211PenetrationEPK13btConvexShapeRK11btTransformS2S5RK9btVector3RNS8sResultsEb(i7);
        r9 = commonVariable.rg0;
        if (r9 == 0) {
            heapClassInst.heap32[g0] = r3;
            heapClassInst.heap32[g0 + 1] = r0;
            heapClassInst.heap32[g0 + numDefine2] = r4;
            heapClassInst.heap32[g0 + numDefine3] = r1;
            heapClassInst.heap32[g0 + numDefine4] = r2;
            heapClassInst.heap32[g0 + numDefine5] = r5;
            zn15btGjkEpaSolver28DistanceEPK13btConvexShapeRK11btTransformS2S5RK9btVector3RNS8sResultsE(i7);
            r0 = commonVariable.rg0;
            if (!(r0 == 0)) {
                r0 = r5 >> numDefine2;
                r1 = r7 >> numDefine2;
                heapClassInst.heap32[r1] = heapClassInst.heap32[r0 + 1];
                heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0 + numDefine2];
                heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + numDefine2];
                r2 = r8 >> numDefine2;
                heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine4];
                heapClassInst.heap32[r2] = heapClassInst.heap32[r0 + numDefine5];
                heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r0 + numDefine6];
                heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r0 + numDefine7];
                r1 = r6 >> numDefine2;
                heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r0 + numDefine8];
                heapClassInst.heap32[r1] = heapClassInst.heap32[r0 + numDefine9];
                heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0 + numDefine10];
                heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + numDefine11];
                heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine12];
            }
            r0 = 0;
            commonVariable.rg0 = r0;
            return;
        } else {
            r0 = r5 >> numDefine2;
            r1 = r7 >> numDefine2;
            heapClassInst.heap32[r1] = heapClassInst.heap32[r0 + 1];
            heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0 + numDefine2];
            heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + numDefine2];
            r2 = r8 >> numDefine2;
            heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine4];
            heapClassInst.heap32[r2] = heapClassInst.heap32[r0 + numDefine5];
            heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r0 + numDefine6];
            heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r0 + numDefine7];
            r1 = r6 >> numDefine2;
            heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r0 + numDefine8];
            heapClassInst.heap32[r1] = heapClassInst.heap32[r0 + numDefine9];
            heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0 + numDefine10];
            heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + numDefine11];
            heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine12];
            r0 = 1;
            commonVariable.rg0 = r0;
            return;
        }
    }

    public static void zn30btGjkEpaPenetrationDepthSolverD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv30btGjkEpaPenetrationDepthSolver;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn30btGjkEpaPenetrationDepthSolverD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv30btGjkEpaPenetrationDepthSolver;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn17btGjkPairDetectorD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv17btGjkPairDetector;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn17btGjkPairDetectorD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv17btGjkPairDetector;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn17btGjkPairDetector16getClosestPointsERKN36btDiscreteCollisionDetectorInterface17ClosestPointInputERNS06ResultEP12btIDebugDrawb(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        int r19 = 0;
        int r20 = 0;
        int r21 = 0;
        int r22 = 0;
        int r23 = 0;
        int r24 = 0;
        int r25 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        float f30 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg304;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = sp + numDefineNeg32;
        heapClassInst.heap32[r1 + numDefine14] = 0;
        r3 = r2 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg8] = 0;
        heapClassInst.heap32[r3 + 1] = 0;
        r4 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[r3 + numDefine2] = 0;
        r5 = sp + numDefineNeg96;
        r4 = r4 >> numDefine2;
        heapClassInst.heap32[r3 + numDefine3] = 0;
        r6 = r5 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg24] = heapClassInst.heap32[r4];
        heapClassInst.heap32[r6 + 1] = heapClassInst.heap32[r4 + 1];
        heapClassInst.heap32[r6 + numDefine2] = heapClassInst.heap32[r4 + numDefine2];
        heapClassInst.heap32[r6 + numDefine3] = heapClassInst.heap32[r4 + numDefine3];
        heapClassInst.heap32[r6 + numDefine4] = heapClassInst.heap32[r4 + numDefine4];
        heapClassInst.heap32[r6 + numDefine5] = heapClassInst.heap32[r4 + numDefine5];
        heapClassInst.heap32[r6 + numDefine6] = heapClassInst.heap32[r4 + numDefine6];
        heapClassInst.heap32[r6 + numDefine7] = heapClassInst.heap32[r4 + numDefine7];
        heapClassInst.heap32[r6 + numDefine8] = heapClassInst.heap32[r4 + numDefine8];
        heapClassInst.heap32[r6 + numDefine9] = heapClassInst.heap32[r4 + numDefine9];
        heapClassInst.heap32[r6 + numDefine10] = heapClassInst.heap32[r4 + numDefine10];
        heapClassInst.heap32[r6 + numDefine11] = heapClassInst.heap32[r4 + numDefine11];
        f0 = heapClassInst.heapFloat[r4 + numDefine12];
        f1 = heapClassInst.heapFloat[r4 + numDefine13];
        f2 = heapClassInst.heapFloat[r4 + numDefine14];
        r7 = sp + numDefineNeg160;
        heapClassInst.heap32[r6 + numDefine15] = heapClassInst.heap32[r4 + numDefine15];
        r8 = r7 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg40] = heapClassInst.heap32[r4 + numDefine16];
        heapClassInst.heap32[r8 + 1] = heapClassInst.heap32[r4 + numDefine17];
        heapClassInst.heap32[r8 + numDefine2] = heapClassInst.heap32[r4 + numDefine18];
        heapClassInst.heap32[r8 + numDefine3] = heapClassInst.heap32[r4 + numDefine19];
        heapClassInst.heap32[r8 + numDefine4] = heapClassInst.heap32[r4 + numDefine20];
        heapClassInst.heap32[r8 + numDefine5] = heapClassInst.heap32[r4 + numDefine21];
        heapClassInst.heap32[r8 + numDefine6] = heapClassInst.heap32[r4 + numDefine22];
        heapClassInst.heap32[r8 + numDefine7] = heapClassInst.heap32[r4 + numDefine23];
        heapClassInst.heap32[r8 + numDefine8] = heapClassInst.heap32[r4 + numDefine24];
        heapClassInst.heap32[r8 + numDefine9] = heapClassInst.heap32[r4 + numDefine25];
        heapClassInst.heap32[r8 + numDefine10] = heapClassInst.heap32[r4 + numDefine26];
        heapClassInst.heap32[r8 + numDefine11] = heapClassInst.heap32[r4 + numDefine27];
        f3 = heapClassInst.heapFloat[r4 + numDefine28];
        f4 = heapClassInst.heapFloat[r4 + numDefine29];
        f5 = heapClassInst.heapFloat[r4 + numDefine30];
        f6 = f0 + f3;
        f7 = (float) numDefineFloat05;
        f6 = f6 * f7;
        f8 = f1 + f4;
        f8 = f8 * f7;
        f9 = f2 + f5;
        f0 = f0 - f6;
        heapClassInst.heap32[r8 + numDefine15] = heapClassInst.heap32[r4 + numDefine31];
        f7 = f9 * f7;
        f1 = f1 - f8;
        heapClassInst.heapFloat[r6 + numDefine12] = f0;
        f0 = f2 - f7;
        heapClassInst.heapFloat[r6 + numDefine13] = f1;
        f1 = f3 - f6;
        heapClassInst.heapFloat[r6 + numDefine14] = f0;
        f0 = f4 - f8;
        heapClassInst.heapFloat[r8 + numDefine12] = f1;
        f1 = f5 - f7;
        heapClassInst.heapFloat[r8 + numDefine13] = f0;
        heapClassInst.heapFloat[r8 + numDefine14] = f1;
        r9 = heapClassInst.heap32[r1 + numDefine7];
        r9 = r9 >> numDefine2;
        r10 = heapClassInst.heap32[fp + numDefine2];
        r11 = heapClassInst.heap32[fp + numDefine3];
        r9 = heapClassInst.heap32[r9 + 1];
        r9 = (r9 + numDefineNeg17) | 0;
        if (uint(r9) > uint(1)) {
            label = numDefine3;
        } else {
            r9 = heapClassInst.heap32[r1 + numDefine8];
            r9 = r9 >> numDefine2;
            r9 = heapClassInst.heap32[r9 + 1];
            r9 = (r9 + numDefineNeg17) | 0;
            if (uint(r9) > uint(1)) {
                label = numDefine3;
            } else {
                r9 = (r0 + numDefine32) | 0;
                r12 = 0;
                label = numDefine4;
            }
        }
        if (label == numDefine3) {
            r9 = (r0 + numDefine32) | 0;
            r12 = 1;
        }
        r13 = gNumGjkChecks;
        r13 = r13 >> numDefine2;
        r14 = heapClassInst.heap32[r13];
        f0 = heapClassInst.heapFloat[r1 + numDefine11];
        f1 = heapClassInst.heapFloat[r1 + numDefine12];
        r14 = (r14 + 1) | 0;
        heapClassInst.heap32[r13] = r14;
        r13 = heapClassInst.heapU8[r0 + numDefine52];
        heapClassInst.heap32[r1 + numDefine16] = 0;
        heapClassInst.heap32[r1 + 1] = 0;
        heapClassInst.heap32[r1 + numDefine2] = numDefine53216;
        heapClassInst.heap32[r1 + numDefine3] = 0;
        heapClassInst.heap32[r1 + numDefine4] = 0;
        heapClassInst.heap32[r1 + numDefine17] = 0;
        heapClassInst.heap32[r1 + numDefine15] = -1;
        r14 = heapClassInst.heap32[r1 + numDefine6];
        r15 = 0;
        r16 = r14 >> numDefine2;
        heapClassInst.heap8[r14 + numDefine312] = (byte) r15;
        r17 = 1;
        heapClassInst.heap32[r16] = 0;
        heapClassInst.heap8[r14 + numDefine356] = (byte) r17;
        heapClassInst.heap32[r16 + numDefine73] = numDefine44395;
        heapClassInst.heap32[r16 + numDefine74] = numDefine44395;
        heapClassInst.heap32[r16 + numDefine75] = numDefine44395;
        heapClassInst.heap32[r16 + numDefine76] = 0;
        heapClassInst.heap8[r14 + numDefine352] = (byte) r15;
        heapClassInst.heap32[r16 + numDefine84] = 0;
        heapClassInst.heap32[r16 + numDefine85] = 0;
        heapClassInst.heap32[r16 + numDefine86] = 0;
        heapClassInst.heap32[r16 + numDefine87] = 0;
        r16 = heapClassInst.heapU8[r14 + numDefine332];
        f2 = 0;
        r16 = r16 & numDefine240;
        heapClassInst.heap8[r14 + numDefine332] = (byte) r16;
        f1 = r13 == r15 ? f1 : f2;
        f0 = r13 == r15 ? f0 : f2;
        f0 = f0 + f1;
        f3 = heapClassInst.heapFloat[r1 + numDefine3];
        f4 = heapClassInst.heapFloat[r1 + numDefine2];
        f5 = heapClassInst.heapFloat[r1 + 1];
        f9 = numDefine49440;
        repeat7: while (true) {
            f10 = -f5;
            f11 = heapClassInst.heapFloat[r4];
            f12 = heapClassInst.heapFloat[r4 + numDefine4];
            f13 = heapClassInst.heapFloat[r4 + 1];
            f14 = heapClassInst.heapFloat[r4 + numDefine5];
            f11 = f11 * f10;
            f12 = f12 * f4;
            f15 = heapClassInst.heapFloat[r4 + numDefine8];
            f16 = heapClassInst.heapFloat[r4 + numDefine2];
            f17 = heapClassInst.heapFloat[r4 + numDefine6];
            f18 = heapClassInst.heapFloat[r4 + numDefine10];
            f19 = heapClassInst.heapFloat[r4 + numDefine9];
            f13 = f13 * f10;
            f14 = f14 * f4;
            f11 = f11 - f12;
            f12 = f15 * f3;
            r13 = sp + numDefineNeg176;
            f10 = f16 * f10;
            f15 = f17 * f4;
            f13 = f13 - f14;
            f14 = f19 * f3;
            f11 = f11 - f12;
            r14 = r13 >> numDefine2;
            f10 = f10 - f15;
            f12 = f18 * f3;
            f13 = f13 - f14;
            heapClassInst.heapFloat[fp + numDefineNeg44] = f11;
            f10 = f10 - f12;
            heapClassInst.heapFloat[r14 + 1] = f13;
            heapClassInst.heapFloat[r14 + numDefine2] = f10;
            heapClassInst.heap32[r14 + numDefine3] = 0;
            f10 = heapClassInst.heapFloat[r4 + numDefine16];
            f11 = heapClassInst.heapFloat[r4 + numDefine20];
            f12 = heapClassInst.heapFloat[r4 + numDefine17];
            f13 = heapClassInst.heapFloat[r4 + numDefine21];
            f14 = heapClassInst.heapFloat[r4 + numDefine24];
            f10 = f10 * f5;
            f11 = f11 * f4;
            f15 = heapClassInst.heapFloat[r4 + numDefine18];
            f16 = heapClassInst.heapFloat[r4 + numDefine22];
            f17 = heapClassInst.heapFloat[r4 + numDefine26];
            f18 = heapClassInst.heapFloat[r4 + numDefine25];
            f12 = f12 * f5;
            f13 = f13 * f4;
            f10 = f10 + f11;
            f11 = f14 * f3;
            r14 = sp + numDefineNeg192;
            f5 = f15 * f5;
            f4 = f16 * f4;
            f12 = f12 + f13;
            f13 = f18 * f3;
            f10 = f10 + f11;
            r16 = r14 >> numDefine2;
            f4 = f5 + f4;
            f3 = f17 * f3;
            f5 = f12 + f13;
            heapClassInst.heapFloat[fp + numDefineNeg48] = f10;
            f3 = f4 + f3;
            heapClassInst.heapFloat[r16 + 1] = f5;
            heapClassInst.heapFloat[r16 + numDefine2] = f3;
            heapClassInst.heap32[r16 + numDefine3] = 0;
            r16 = heapClassInst.heap32[r1 + numDefine7];
            r18 = sp + numDefineNeg208;
            heapClassInst.heap32[g0] = r18;
            heapClassInst.heap32[g0 + 1] = r16;
            heapClassInst.heap32[g0 + numDefine2] = r13;
            r13 = r9 >> numDefine2;
            znk13btConvexShape44localGetSupportVertexWithoutMarginNonVirtualERK9btVector3(i7);
            r16 = heapClassInst.heap32[r13];
            r19 = sp + numDefineNeg224;
            heapClassInst.heap32[g0] = r19;
            heapClassInst.heap32[g0 + 1] = r16;
            heapClassInst.heap32[g0 + numDefine2] = r14;
            znk13btConvexShape44localGetSupportVertexWithoutMarginNonVirtualERK9btVector3(i7);
            r14 = r18 >> numDefine2;
            r16 = r19 >> numDefine2;
            f3 = heapClassInst.heapFloat[r6 + numDefine8];
            f4 = heapClassInst.heapFloat[fp + numDefineNeg52];
            f5 = heapClassInst.heapFloat[r6 + numDefine4];
            f10 = heapClassInst.heapFloat[fp + numDefineNeg24];
            f11 = heapClassInst.heapFloat[r6 + numDefine9];
            f12 = heapClassInst.heapFloat[r14 + 1];
            f13 = heapClassInst.heapFloat[r6 + numDefine5];
            f14 = heapClassInst.heapFloat[r6 + 1];
            f15 = heapClassInst.heapFloat[r8 + numDefine8];
            f16 = heapClassInst.heapFloat[fp + numDefineNeg56];
            f17 = heapClassInst.heapFloat[r8 + numDefine4];
            f18 = heapClassInst.heapFloat[fp + numDefineNeg40];
            f19 = heapClassInst.heapFloat[r8 + numDefine9];
            f20 = heapClassInst.heapFloat[r16 + 1];
            f21 = heapClassInst.heapFloat[r8 + numDefine5];
            f22 = heapClassInst.heapFloat[r8 + 1];
            f3 = f3 * f4;
            f11 = f11 * f12;
            f23 = heapClassInst.heapFloat[r6 + numDefine10];
            f24 = heapClassInst.heapFloat[r14 + numDefine2];
            f25 = heapClassInst.heapFloat[r6 + numDefine6];
            f26 = heapClassInst.heapFloat[r6 + numDefine2];
            f15 = f15 * f16;
            f19 = f19 * f20;
            f27 = heapClassInst.heapFloat[r8 + numDefine10];
            f28 = heapClassInst.heapFloat[r16 + numDefine2];
            f29 = heapClassInst.heapFloat[r8 + numDefine6];
            f30 = heapClassInst.heapFloat[r8 + numDefine2];
            f5 = f5 * f4;
            f13 = f13 * f12;
            f17 = f17 * f16;
            f21 = f21 * f20;
            f4 = f10 * f4;
            f10 = f14 * f12;
            f12 = f18 * f16;
            f14 = f22 * f20;
            f3 = f3 + f11;
            f11 = f23 * f24;
            f15 = f15 + f19;
            f16 = f27 * f28;
            f5 = f5 + f13;
            f13 = f25 * f24;
            f17 = f17 + f21;
            f18 = f29 * f28;
            f4 = f4 + f10;
            f10 = f26 * f24;
            f12 = f12 + f14;
            f14 = f30 * f28;
            f3 = f3 + f11;
            f11 = heapClassInst.heapFloat[r6 + numDefine14];
            f15 = f15 + f16;
            f16 = heapClassInst.heapFloat[r8 + numDefine14];
            f5 = f5 + f13;
            f13 = heapClassInst.heapFloat[r6 + numDefine13];
            f17 = f17 + f18;
            f18 = heapClassInst.heapFloat[r8 + numDefine13];
            f4 = f4 + f10;
            f10 = heapClassInst.heapFloat[r6 + numDefine12];
            f12 = f12 + f14;
            f14 = heapClassInst.heapFloat[r8 + numDefine12];
            f5 = f5 + f13;
            f13 = f17 + f18;
            f4 = f4 + f10;
            f10 = f12 + f14;
            f3 = f3 + f11;
            f11 = f15 + f16;
            f3 = r12 != r15 ? f3 : f2;
            f11 = r12 != r15 ? f11 : f2;
            f12 = f5 - f13;
            f14 = heapClassInst.heapFloat[r1 + numDefine2];
            f15 = f4 - f10;
            f16 = heapClassInst.heapFloat[r1 + 1];
            f17 = f3 - f11;
            f18 = heapClassInst.heapFloat[r1 + numDefine3];
            f16 = f16 * f15;
            f14 = f14 * f12;
            f14 = f16 + f14;
            f16 = f18 * f17;
            f14 = f14 + f16;
            if (!(f14 <= f2)) {
                f16 = heapClassInst.heapFloat[r4 + numDefine32];
                f18 = f14 * f14;
                f16 = f16 * f9;
                if (!(f18 <= f16)) {
                    label = numDefine7;
                    break repeat7;
                }
            }
            r14 = heapClassInst.heap32[r1 + numDefine6];
            r16 = r14 >> numDefine2;
            r18 = heapClassInst.heap32[r16];
            repeat12: do {
                if (r18 > 0) {
                    r19 = numDefineNeg12;
                    f16 = heapClassInst.heapFloat[r16 + numDefine77];
                    r20 = (r19 - r14) | 0;
                    r21 = 0;
                    r22 = r18;
                    r19 = r21;
                    repeat14: while (true) {
                        r23 = numDefineNeg8;
                        r24 = numDefineNeg4;
                        r23 = (r23 - r20) | 0;
                        r24 = (r24 - r20) | 0;
                        r23 = r23 >> numDefine2;
                        r24 = r24 >> numDefine2;
                        r25 = (r21 - r20) | 0;
                        r25 = r25 >> numDefine2;
                        f18 = heapClassInst.heapFloat[r23];
                        f19 = heapClassInst.heapFloat[r24];
                        f18 = f15 - f18;
                        f19 = f12 - f19;
                        f20 = heapClassInst.heapFloat[r25];
                        f20 = f17 - f20;
                        f18 = f18 * f18;
                        f19 = f19 * f19;
                        f18 = f18 + f19;
                        f19 = f20 * f20;
                        f18 = f18 + f19;
                        r22 = (r22 + -1) | 0;
                        r19 = f18 > f16 ? r19 : r17;
                        r20 = (r20 + numDefineNeg16) | 0;
                        if (r22 != 0) {
                            continue repeat14;
                        } else {
                            break repeat12;
                        }
                    }
                } else {
                    r19 = r15;
                }
            } while (false);
            f16 = heapClassInst.heapFloat[r16 + numDefine76];
            if (f16 == f2) {
                f16 = heapClassInst.heapFloat[r16 + numDefine75];
                if (!(f17 != f16)) {
                    f16 = heapClassInst.heapFloat[r16 + numDefine74];
                    if (!(f12 != f16)) {
                        f16 = heapClassInst.heapFloat[r16 + numDefine73];
                        r19 = f15 != f16 ? r19 : r17;
                    }
                }
            }
            r19 = r19 & numDefine255;
            if (r19 == 0) {
                f14 = f9 - f14;
                f16 = (float) numDefineFloat9717;
                f18 = f9 * f16;
                if (f14 > f18) {
                    heapClassInst.heapFloat[r16 + numDefine73] = f15;
                    heapClassInst.heapFloat[r16 + numDefine74] = f12;
                    r18 = r18 << numDefine4;
                    heapClassInst.heapFloat[r16 + numDefine75] = f17;
                    r18 = (r14 + r18) | 0;
                    heapClassInst.heap32[r16 + numDefine76] = 0;
                    r18 = r18 >> numDefine2;
                    heapClassInst.heap8[r14 + numDefine356] = (byte) r17;
                    heapClassInst.heapFloat[r18 + 1] = f15;
                    heapClassInst.heapFloat[r18 + numDefine2] = f12;
                    heapClassInst.heapFloat[r18 + numDefine3] = f17;
                    heapClassInst.heap32[r18 + numDefine4] = 0;
                    r18 = heapClassInst.heap32[r16];
                    r18 = r18 << numDefine4;
                    r18 = (r14 + r18) | 0;
                    r18 = r18 >> numDefine2;
                    heapClassInst.heapFloat[r18 + numDefine21] = f4;
                    heapClassInst.heapFloat[r18 + numDefine22] = f5;
                    heapClassInst.heapFloat[r18 + numDefine23] = f3;
                    heapClassInst.heap32[r18 + numDefine24] = 0;
                    r18 = heapClassInst.heap32[r16];
                    r18 = r18 << numDefine4;
                    r14 = (r14 + r18) | 0;
                    r14 = r14 >> numDefine2;
                    heapClassInst.heapFloat[r14 + numDefine41] = f10;
                    heapClassInst.heapFloat[r14 + numDefine42] = f13;
                    heapClassInst.heapFloat[r14 + numDefine43] = f11;
                    heapClassInst.heap32[r14 + numDefine44] = 0;
                    r14 = heapClassInst.heap32[r16];
                    r14 = (r14 + 1) | 0;
                    heapClassInst.heap32[r16] = r14;
                    r14 = heapClassInst.heap32[r1 + numDefine6];
                    heapClassInst.heap32[g0] = r14;
                    zn22btVoronoiSimplexSolver28updateClosestVectorAndPointsEv(i7);
                    r16 = commonVariable.rg0;
                    if (r16 != 0) {
                        r14 = r14 >> numDefine2;
                        f5 = heapClassInst.heapFloat[r14 + numDefine69];
                        f4 = heapClassInst.heapFloat[r14 + numDefine70];
                        f3 = heapClassInst.heapFloat[r14 + numDefine71];
                        f10 = heapClassInst.heapFloat[r14 + numDefine72];
                        heapClassInst.heapFloat[r1 + 1] = f5;
                        f11 = f5 * f5;
                        f12 = f4 * f4;
                        heapClassInst.heapFloat[r1 + numDefine2] = f4;
                        f11 = f11 + f12;
                        f12 = f3 * f3;
                        f11 = f11 + f12;
                        heapClassInst.heapFloat[r1 + numDefine3] = f3;
                        heapClassInst.heapFloat[r1 + numDefine4] = f10;
                        if (f11 >= f16) {
                            f10 = (float) numDefineFloat1257;
                            f12 = f9 - f11;
                            f9 = f9 * f10;
                            if (f12 > f9) {
                                r14 = heapClassInst.heap32[r1 + numDefine16];
                                r16 = (r14 + 1) | 0;
                                heapClassInst.heap32[r1 + numDefine16] = r16;
                                if (r14 < numDefine1001) {
                                    r14 = heapClassInst.heap32[r1 + numDefine6];
                                    r14 = r14 >> numDefine2;
                                    r16 = heapClassInst.heap32[r14];
                                    f9 = f11;
                                    if (r16 != numDefine4) {
                                        continue repeat7;
                                    } else {
                                        label = numDefine29;
                                        break repeat7;
                                    }
                                } else {
                                    label = numDefine27;
                                    break repeat7;
                                }
                            } else {
                                label = numDefine25;
                                break repeat7;
                            }
                        } else {
                            label = numDefine23;
                            break repeat7;
                        }
                    } else {
                        label = numDefine21;
                        break repeat7;
                    }
                } else {
                    label = numDefine19;
                    break repeat7;
                }
            } else {
                label = numDefine17;
                break repeat7;
            }
        }
        repeat29: do {
            switch (label) {
                case numDefine7:
                    heapClassInst.heap32[r1 + numDefine17] = numDefine10;
                    label = numDefine30;
                    break repeat29;
                case numDefine29:
                    heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r14 + numDefine69];
                    heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r14 + numDefine70];
                    heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r14 + numDefine71];
                    r17 = 0;
                    heapClassInst.heap32[r1 + numDefine4] = heapClassInst.heap32[r14 + numDefine72];
                    heapClassInst.heap32[r1 + numDefine17] = numDefine13;
                    label = numDefine37;
                    break repeat29;
                case numDefine27:
                    r6 = twoEStr425;
                    heapClassInst.heap32[g0] = r6;
                    heapClassInst.heap32[g0 + 1] = r16;
                    printf(i7);
                    r6 = heapClassInst.heap32[r13];
                    r8 = heapClassInst.heap32[r1 + numDefine7];
                    r6 = r6 >> numDefine2;
                    r8 = r8 >> numDefine2;
                    f2 = heapClassInst.heapFloat[r1 + numDefine3];
                    f3 = heapClassInst.heapFloat[r1 + numDefine2];
                    f4 = heapClassInst.heapFloat[r1 + 1];
                    r6 = heapClassInst.heap32[r6 + 1];
                    r8 = heapClassInst.heap32[r8 + 1];
                    r9 = twoEStr1426;
                    heapClassInst.heap32[g0] = r9;
                    llvmWriteDouble(i7 + numDefine8, (int) f4);
                    llvmWriteDouble(i7 + numDefine16, (int) f3);
                    llvmWriteDouble(i7 + numDefine24, (int) f2);
                    llvmWriteDouble(i7 + numDefine32, (int) f5);
                    heapClassInst.heap32[g0 + numDefine10] = r8;
                    heapClassInst.heap32[g0 + numDefine11] = r6;
                    f2 = 0;
                    r17 = 0;
                    printf(i7);
                    label = numDefine37;
                    break repeat29;
                case numDefine25:
                    r6 = heapClassInst.heap32[r1 + numDefine6];
                    r6 = r6 >> numDefine2;
                    heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r6 + numDefine69];
                    heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r6 + numDefine70];
                    heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r6 + numDefine71];
                    heapClassInst.heap32[r1 + numDefine4] = heapClassInst.heap32[r6 + numDefine72];
                    heapClassInst.heap32[r1 + numDefine17] = numDefine12;
                    f9 = f11;
                    label = numDefine30;
                    break repeat29;
                case numDefine23:
                    heapClassInst.heap32[r1 + numDefine17] = numDefine6;
                    label = numDefine30;
                    break repeat29;
                case numDefine21:
                    heapClassInst.heap32[r1 + numDefine17] = numDefine3;
                    label = numDefine30;
                    break repeat29;
                case numDefine19:
                    r6 = numDefine11;
                    r8 = numDefine2;
                    heapClassInst.heap32[r1 + numDefine17] = r6;
                    label = numDefine30;
                    break repeat29;
                case numDefine17:
                    heapClassInst.heap32[r1 + numDefine17] = 1;
                    label = numDefine30;
                    break;
                default:
                    break;
            }
        } while (false);
        if (label == numDefine30) {
            r6 = heapClassInst.heap32[r1 + numDefine6];
            heapClassInst.heap32[g0] = r6;
            r6 = r6 >> numDefine2;
            zn22btVoronoiSimplexSolver28updateClosestVectorAndPointsEv(i7);
            f3 = heapClassInst.heapFloat[r6 + numDefine65];
            f2 = heapClassInst.heapFloat[r6 + numDefine61];
            f4 = heapClassInst.heapFloat[r6 + numDefine66];
            f5 = heapClassInst.heapFloat[r6 + numDefine62];
            f10 = heapClassInst.heapFloat[r6 + numDefine67];
            f11 = heapClassInst.heapFloat[r6 + numDefine63];
            f2 = f2 - f3;
            f5 = f5 - f4;
            heapClassInst.heapFloat[fp + numDefineNeg8] = f2;
            f2 = f11 - f10;
            heapClassInst.heapFloat[r3 + 1] = f5;
            heapClassInst.heapFloat[r3 + numDefine2] = f2;
            heapClassInst.heap32[r3 + numDefine3] = 0;
            f2 = heapClassInst.heapFloat[r1 + 1];
            f5 = heapClassInst.heapFloat[r1 + numDefine2];
            f11 = heapClassInst.heapFloat[r1 + numDefine3];
            f2 = f2 * f2;
            f5 = f5 * f5;
            f2 = f2 + f5;
            f5 = f11 * f11;
            f2 = f2 + f5;
            f5 = f2;
            f11 = (float) numDefineFloat0001;
            if (!(f5 >= f11)) {
                heapClassInst.heap32[r1 + numDefine17] = numDefine5;
            }
            f5 = (float) numDefineFloat4044;
            if (f2 <= f5) {
                f2 = 0;
                r17 = 0;
                heapClassInst.heap32[r1 + numDefine15] = numDefine2;
            } else {
                heapClassInst.heapFloat[g0] = f2;
                sqrtf(i7);
                f5 = 1;
                f2 = (float) (f5 / commonVariable.fg0);
                f11 = heapClassInst.heapFloat[fp + numDefineNeg8];
                f11 = f11 * f2;
                heapClassInst.heapFloat[fp + numDefineNeg8] = f11;
                f11 = heapClassInst.heapFloat[r3 + 1];
                f11 = f11 * f2;
                heapClassInst.heapFloat[r3 + 1] = f11;
                f11 = heapClassInst.heapFloat[r3 + numDefine2];
                f11 = f11 * f2;
                heapClassInst.heapFloat[r3 + numDefine2] = f11;
                heapClassInst.heapFloat[g0] = f9;
                sqrtf(i7);
                f9 = (float) commonVariable.fg0;
                f11 = 0;
                if (f9 > f11) {
                    f9 = f1 / f9;
                    f11 = heapClassInst.heapFloat[r1 + numDefine3];
                    f12 = heapClassInst.heapFloat[r1 + numDefine2];
                    f13 = heapClassInst.heapFloat[r1 + 1];
                    f13 = f13 * f9;
                    f12 = f12 * f9;
                    f9 = f11 * f9;
                    f2 = f5 / f2;
                    f3 = f3 + f13;
                    f4 = f4 + f12;
                    f10 = f10 + f9;
                    f2 = f2 - f0;
                    heapClassInst.heap32[r1 + numDefine15] = 1;
                } else {
                    r0 = twoEStr2427;
                    r1 = twoEStr3428;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine320;
                    assertNew(i7);
                }
            }
        }
        r6 = heapClassInst.heap32[r1 + numDefine18];
        if (r6 == 0) {
            label = numDefine42;
        } else {
            r6 = heapClassInst.heap32[r1 + numDefine5];
            if (r6 == 0) {
                label = numDefine42;
            } else {
                r8 = heapClassInst.heap32[r1 + numDefine17];
                if (r8 == 0) {
                    label = numDefine42;
                } else {
                    f5 = f2 + f0;
                    f9 = (float) numDefineFloat001;
                    if (f5 < f9) {
                        label = numDefine44;
                    } else {
                        r8 = r17 & numDefine255;
                        if (r8 == 1) {
                            label = numDefine60;
                        } else {
                            label = numDefine44;
                        }
                    }
                }
            }
        }
        if (label == numDefine42) {
            r6 = r17 & numDefine255;
            if (r6 == 1) {
                label = numDefine60;
            } else {
                r6 = heapClassInst.heap32[r1 + numDefine5];
                if (r6 == 0) {
                    label = numDefine59;
                } else {
                    label = numDefine44;
                }
            }
        }
        repeat58: do {
            if (label == numDefine44) {
                r8 = gNumDeepPenetrationChecks;
                r8 = r8 >> numDefine2;
                r9 = heapClassInst.heap32[r8];
                r9 = (r9 + 1) | 0;
                heapClassInst.heap32[r8] = r9;
                heapClassInst.heap32[r1 + 1] = 0;
                heapClassInst.heap32[r1 + numDefine2] = 0;
                heapClassInst.heap32[r1 + numDefine3] = 0;
                heapClassInst.heap32[r1 + numDefine4] = 0;
                r8 = r6 >> numDefine2;
                r8 = heapClassInst.heap32[r8];
                r8 = r8 >> numDefine2;
                r8 = heapClassInst.heap32[r8 + numDefine2];
                r9 = heapClassInst.heap32[r4 + numDefine33];
                r12 = heapClassInst.heap32[r13];
                r13 = heapClassInst.heap32[r1 + numDefine7];
                r14 = heapClassInst.heap32[r1 + numDefine6];
                r0 = (r0 + numDefine4) | 0;
                r15 = sp + numDefineNeg240;
                r16 = sp + numDefineNeg256;
                heapClassInst.heap32[g0] = r6;
                heapClassInst.heap32[g0 + 1] = r14;
                heapClassInst.heap32[g0 + numDefine2] = r13;
                heapClassInst.heap32[g0 + numDefine3] = r12;
                heapClassInst.heap32[g0 + numDefine4] = r5;
                heapClassInst.heap32[g0 + numDefine5] = r7;
                heapClassInst.heap32[g0 + numDefine6] = r0;
                heapClassInst.heap32[g0 + numDefine7] = r15;
                heapClassInst.heap32[g0 + numDefine8] = r16;
                heapClassInst.heap32[g0 + numDefine9] = r11;
                heapClassInst.heap32[g0 + numDefine10] = r9;
                functionTable.get(r8 >> numDefine2).accept(i7);
                r0 = commonVariable.rg0;
                if (r0 == 0) {
                    f5 = heapClassInst.heapFloat[r1 + 1];
                    f9 = heapClassInst.heapFloat[r1 + numDefine2];
                    f11 = heapClassInst.heapFloat[r1 + numDefine3];
                    f5 = f5 * f5;
                    f9 = f9 * f9;
                    f5 = f5 + f9;
                    f9 = f11 * f11;
                    f5 = f5 + f9;
                    f9 = 0;
                    if (f5 <= f9) {
                        label = numDefine59;
                        break repeat58;
                    } else {
                        r0 = r15 >> numDefine2;
                        r5 = r16 >> numDefine2;
                        f5 = heapClassInst.heapFloat[r0 + 1];
                        f9 = heapClassInst.heapFloat[r5 + 1];
                        f11 = heapClassInst.heapFloat[fp + numDefineNeg60];
                        f12 = heapClassInst.heapFloat[fp + numDefineNeg64];
                        f11 = f11 - f12;
                        f5 = f5 - f9;
                        f9 = heapClassInst.heapFloat[r0 + numDefine2];
                        f12 = heapClassInst.heapFloat[r5 + numDefine2];
                        f9 = f9 - f12;
                        f11 = f11 * f11;
                        f5 = f5 * f5;
                        f5 = f11 + f5;
                        f9 = f9 * f9;
                        f5 = f5 + f9;
                        heapClassInst.heapFloat[g0] = f5;
                        sqrtf(i7);
                        f0 = (float) (commonVariable.fg0 - f0);
                        r0 = r17 & numDefine255;
                        if (!(r0 != 1)) {
                            if (f0 >= f2) {
                                heapClassInst.heap32[r1 + numDefine15] = numDefine5;
                                label = numDefine59;
                                break repeat58;
                            }
                        }
                        f2 = heapClassInst.heapFloat[r1 + 1];
                        f3 = heapClassInst.heapFloat[r1 + numDefine2];
                        f4 = heapClassInst.heapFloat[r1 + numDefine3];
                        f10 = heapClassInst.heapFloat[fp + numDefineNeg64];
                        f5 = heapClassInst.heapFloat[r5 + 1];
                        f9 = heapClassInst.heapFloat[r5 + numDefine2];
                        heapClassInst.heapFloat[fp + numDefineNeg8] = f2;
                        heapClassInst.heapFloat[r3 + 1] = f3;
                        heapClassInst.heapFloat[r3 + numDefine2] = f4;
                        f11 = f2 * f2;
                        f12 = f3 * f3;
                        heapClassInst.heap32[r3 + numDefine3] = heapClassInst.heap32[r1 + numDefine4];
                        f11 = f11 + f12;
                        f12 = f4 * f4;
                        f11 = f11 + f12;
                        heapClassInst.heapFloat[g0] = f11;
                        sqrtf(i7);
                        f12 = 1;
                        f11 = (float) (f12 / commonVariable.fg0);
                        f12 = heapClassInst.heapFloat[fp + numDefineNeg8];
                        f12 = f12 * f11;
                        heapClassInst.heapFloat[fp + numDefineNeg8] = f12;
                        f12 = heapClassInst.heapFloat[r3 + 1];
                        f12 = f12 * f11;
                        heapClassInst.heapFloat[r3 + 1] = f12;
                        f12 = heapClassInst.heapFloat[r3 + numDefine2];
                        f2 = f2 * f1;
                        f13 = f3 * f1;
                        f1 = f4 * f1;
                        f11 = f12 * f11;
                        f3 = f10 + f2;
                        f4 = f5 + f13;
                        f10 = f9 + f1;
                        heapClassInst.heapFloat[r3 + numDefine2] = f11;
                        heapClassInst.heap32[r1 + numDefine15] = numDefine6;
                        f2 = f0;
                        label = numDefine60;
                        break repeat58;
                    }
                } else {
                    r16 = r16 >> numDefine2;
                    r15 = r15 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r16 + 1];
                    f1 = heapClassInst.heapFloat[r15 + 1];
                    f5 = heapClassInst.heapFloat[fp + numDefineNeg64];
                    f9 = heapClassInst.heapFloat[fp + numDefineNeg60];
                    f0 = f0 - f1;
                    f1 = f5 - f9;
                    f5 = heapClassInst.heapFloat[r16 + numDefine2];
                    f9 = heapClassInst.heapFloat[r15 + numDefine2];
                    f5 = f5 - f9;
                    f9 = f1 * f1;
                    f11 = f0 * f0;
                    f9 = f9 + f11;
                    f11 = f5 * f5;
                    f9 = f9 + f11;
                    f11 = (float) numDefineFloat4044;
                    if (f9 <= f11) {
                        f1 = heapClassInst.heapFloat[r1 + 1];
                        f0 = heapClassInst.heapFloat[r1 + numDefine2];
                        f5 = heapClassInst.heapFloat[r1 + numDefine3];
                        f9 = f1 * f1;
                        f12 = f0 * f0;
                        f9 = f9 + f12;
                        f13 = f5 * f5;
                        f12 = heapClassInst.heapFloat[r1 + numDefine4];
                        f9 = f9 + f13;
                    } else {
                        f12 = 0;
                    }
                    if (f9 <= f11) {
                        heapClassInst.heap32[r1 + numDefine15] = numDefine9;
                        label = numDefine59;
                        break repeat58;
                    } else {
                        heapClassInst.heapFloat[g0] = f9;
                        sqrtf(i7);
                        f9 = (float) commonVariable.fg0;
                        f11 = heapClassInst.heapFloat[r15 + 1];
                        f13 = heapClassInst.heapFloat[r16 + 1];
                        f14 = heapClassInst.heapFloat[fp + numDefineNeg60];
                        f15 = heapClassInst.heapFloat[fp + numDefineNeg64];
                        f14 = f14 - f15;
                        f11 = f11 - f13;
                        f13 = heapClassInst.heapFloat[r15 + numDefine2];
                        f15 = heapClassInst.heapFloat[r16 + numDefine2];
                        f13 = f13 - f15;
                        f14 = f14 * f14;
                        f11 = f11 * f11;
                        f11 = f14 + f11;
                        f13 = f13 * f13;
                        f11 = f11 + f13;
                        heapClassInst.heapFloat[g0] = f11;
                        sqrtf(i7);
                        f11 = (float) -commonVariable.fg0;
                        r15 = r17 & numDefine255;
                        if (!(r15 != 1)) {
                            if (f2 <= f11) {
                                heapClassInst.heap32[r1 + numDefine15] = numDefine8;
                                label = numDefine59;
                                break repeat58;
                            }
                        }
                        f2 = 1;
                        f2 = f2 / f9;
                        f3 = heapClassInst.heapFloat[fp + numDefineNeg64];
                        f4 = heapClassInst.heapFloat[r16 + 1];
                        f10 = heapClassInst.heapFloat[r16 + numDefine2];
                        f1 = f1 * f2;
                        f0 = f0 * f2;
                        heapClassInst.heapFloat[fp + numDefineNeg8] = f1;
                        f1 = f5 * f2;
                        heapClassInst.heapFloat[r3 + 1] = f0;
                        heapClassInst.heapFloat[r3 + numDefine2] = f1;
                        heapClassInst.heapFloat[r3 + numDefine3] = f12;
                        heapClassInst.heap32[r1 + numDefine15] = numDefine3;
                        f2 = f11;
                        label = numDefine60;
                    }
                }
            }
        } while (false);
        if (label == numDefine59) {
            r0 = r17 & numDefine255;
            if (r0 == 0) {
                label = numDefine63;
            } else {
                label = numDefine60;
            }
        }
        repeat81: do {
            if (label == numDefine60) {
                f0 = 0;
                if (!(f2 < f0)) {
                    f0 = f2 * f2;
                    f1 = heapClassInst.heapFloat[r4 + numDefine32];
                    if (f0 >= f1) {
                        break repeat81;
                    }
                }
                heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[fp + numDefineNeg8];
                heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r3 + 1];
                heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r3 + numDefine3];
                heapClassInst.heap32[r1 + numDefine4] = heapClassInst.heap32[r3 + numDefine3];
                r0 = r10 >> numDefine2;
                heapClassInst.heapFloat[r1 + numDefine14] = f2;
                r0 = heapClassInst.heap32[r0];
                r0 = r0 >> numDefine2;
                r0 = heapClassInst.heap32[r0 + numDefine4];
                r1 = sp + numDefineNeg16;
                f0 = f3 + f6;
                r3 = r1 >> numDefine2;
                f1 = f4 + f8;
                heapClassInst.heapFloat[fp + numDefineNeg4] = f0;
                heapClassInst.heapFloat[r3 + 1] = f1;
                heapClassInst.heapFloat[r3 + numDefine2] = f0;
                heapClassInst.heap32[r3 + numDefine3] = 0;
                heapClassInst.heap32[g0] = r10;
                heapClassInst.heap32[g0 + 1] = r2;
                heapClassInst.heap32[g0 + numDefine2] = r1;
                heapClassInst.heapFloat[g0 + numDefine3] = f2;
                functionTable.get(r0 >> numDefine2).accept(i7);
            }
        } while (false);
        return;
    }

    public static void zn20btPersistentManifold18removeContactPointEi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine279];
        r3 = (r2 + -1) | 0;
        r4 = heapClassInst.heap32[fp + 1];
        if (r3 == r4) {
            r3 = (r2 * numDefine276) | 0;
            r0 = (r0 + r3) | 0;
            r0 = r0 >> numDefine2;
            r0 = heapClassInst.heap32[r0 + numDefineNeg41];
            if (r0 != 0) {
                r1 = twoEStr434;
                r2 = twoEStr483;
                heapClassInst.heap32[g0] = r1;
                heapClassInst.heap32[g0 + 1] = r2;
                heapClassInst.heap32[g0 + numDefine2] = numDefine160;
                assertNew(i7);
            }
        } else {
            r4 = (r4 * numDefine276) | 0;
            r5 = (r0 + numDefine4) | 0;
            r3 = (r3 * numDefine276) | 0;
            r4 = (r5 + r4) | 0;
            r3 = (r5 + r3) | 0;
            r2 = (r2 * numDefine276) | 0;
            heapClassInst.heap32[g0] = r4;
            heapClassInst.heap32[g0 + 1] = r3;
            heapClassInst.heap32[g0 + numDefine2] = numDefine276;
            r0 = (r0 + r2) | 0;
            memcpy(i7);
            r2 = r0 >> numDefine2;
            heapClassInst.heap32[r2 + numDefineNeg41] = 0;
            heapClassInst.heap32[r2 + numDefineNeg16] = 0;
            heapClassInst.heap32[r2 + numDefineNeg8] = 0;
            heapClassInst.heap32[r2] = 0;
            r3 = 0;
            heapClassInst.heap32[r2 + numDefineNeg40] = 0;
            heapClassInst.heap8[r0 + numDefineNeg156] = (byte) r3;
            heapClassInst.heap32[r2 + numDefineNeg38] = 0;
            heapClassInst.heap32[r2 + numDefineNeg37] = 0;
            heapClassInst.heap32[r2 + numDefineNeg32] = 0;
            r2 = heapClassInst.heap32[r1 + numDefine279];
        }
        r0 = (r2 + -1) | 0;
        heapClassInst.heap32[r1 + numDefine279] = r0;
        return;
    }

    public static void zn20btPersistentManifold20refreshContactPointsERK11btTransformS2(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine279];
        r3 = (r2 + -1) | 0;
        if (r3 > -1) {
            r3 = heapClassInst.heap32[fp + 1];
            r4 = heapClassInst.heap32[fp + numDefine2];
            repeat3: while (true) {
                r5 = (r2 * numDefine69) | 0;
                r5 = r5 << numDefine2;
                r5 = (r0 + r5) | 0;
                r6 = r3 >> numDefine2;
                r5 = r5 >> numDefine2;
                f0 = heapClassInst.heapFloat[r5 + numDefineNeg68];
                f1 = heapClassInst.heapFloat[r6];
                f2 = heapClassInst.heapFloat[r5 + numDefineNeg67];
                f3 = heapClassInst.heapFloat[r6 + 1];
                f4 = heapClassInst.heapFloat[r6 + numDefine4];
                f5 = heapClassInst.heapFloat[r6 + numDefine5];
                f1 = f1 * f0;
                f3 = f3 * f2;
                f6 = heapClassInst.heapFloat[r5 + numDefineNeg66];
                f7 = heapClassInst.heapFloat[r6 + numDefine2];
                f8 = heapClassInst.heapFloat[r6 + numDefine8];
                f9 = heapClassInst.heapFloat[r6 + numDefine9];
                f10 = heapClassInst.heapFloat[r6 + numDefine6];
                f4 = f4 * f0;
                f5 = f5 * f2;
                f1 = f1 + f3;
                f3 = f7 * f6;
                f7 = heapClassInst.heapFloat[r6 + numDefine10];
                f0 = f8 * f0;
                f2 = f9 * f2;
                f4 = f4 + f5;
                f5 = f10 * f6;
                f1 = f1 + f3;
                f3 = heapClassInst.heapFloat[r6 + numDefine12];
                f8 = heapClassInst.heapFloat[r6 + numDefine14];
                f9 = heapClassInst.heapFloat[r6 + numDefine13];
                f4 = f4 + f5;
                f0 = f0 + f2;
                f2 = f7 * f6;
                f1 = f1 + f3;
                f0 = f0 + f2;
                f2 = f4 + f9;
                heapClassInst.heapFloat[r5 + numDefineNeg56] = f1;
                f0 = f0 + f8;
                heapClassInst.heapFloat[r5 + numDefineNeg55] = f2;
                heapClassInst.heapFloat[r5 + numDefineNeg54] = f0;
                heapClassInst.heap32[r5 + numDefineNeg53] = 0;
                r6 = r4 >> numDefine2;
                f0 = heapClassInst.heapFloat[r5 + numDefineNeg64];
                f1 = heapClassInst.heapFloat[r6];
                f2 = heapClassInst.heapFloat[r5 + numDefineNeg63];
                f3 = heapClassInst.heapFloat[r6 + 1];
                f4 = heapClassInst.heapFloat[r6 + numDefine4];
                f5 = heapClassInst.heapFloat[r6 + numDefine5];
                f1 = f1 * f0;
                f3 = f3 * f2;
                f6 = heapClassInst.heapFloat[r5 + numDefineNeg62];
                f7 = heapClassInst.heapFloat[r6 + numDefine2];
                f8 = heapClassInst.heapFloat[r6 + numDefine8];
                f9 = heapClassInst.heapFloat[r6 + numDefine9];
                f10 = heapClassInst.heapFloat[r6 + numDefine6];
                f4 = f4 * f0;
                f5 = f5 * f2;
                f1 = f1 + f3;
                f3 = f7 * f6;
                f7 = heapClassInst.heapFloat[r6 + numDefine10];
                f0 = f8 * f0;
                f2 = f9 * f2;
                f4 = f4 + f5;
                f5 = f10 * f6;
                f1 = f1 + f3;
                f3 = heapClassInst.heapFloat[r6 + numDefine12];
                f8 = heapClassInst.heapFloat[r6 + numDefine14];
                f9 = heapClassInst.heapFloat[r6 + numDefine13];
                f4 = f4 + f5;
                f0 = f0 + f2;
                f2 = f7 * f6;
                f1 = f1 + f3;
                f0 = f0 + f2;
                f2 = f4 + f9;
                heapClassInst.heapFloat[r5 + numDefineNeg60] = f1;
                f0 = f0 + f8;
                heapClassInst.heapFloat[r5 + numDefineNeg59] = f2;
                heapClassInst.heapFloat[r5 + numDefineNeg58] = f0;
                heapClassInst.heap32[r5 + numDefineNeg57] = 0;
                f0 = heapClassInst.heapFloat[r5 + numDefineNeg55];
                f1 = heapClassInst.heapFloat[r5 + numDefineNeg59];
                f2 = heapClassInst.heapFloat[r5 + numDefineNeg56];
                f3 = heapClassInst.heapFloat[r5 + numDefineNeg60];
                f2 = f2 - f3;
                f3 = heapClassInst.heapFloat[r5 + numDefineNeg52];
                f0 = f0 - f1;
                f1 = heapClassInst.heapFloat[r5 + numDefineNeg51];
                f4 = heapClassInst.heapFloat[r5 + numDefineNeg54];
                f5 = heapClassInst.heapFloat[r5 + numDefineNeg58];
                f6 = heapClassInst.heapFloat[r5 + numDefineNeg50];
                f4 = f4 - f5;
                f2 = f2 * f3;
                f0 = f0 * f1;
                f0 = f2 + f0;
                f1 = f4 * f6;
                f0 = f0 + f1;
                heapClassInst.heapFloat[r5 + numDefineNeg48] = f0;
                r6 = heapClassInst.heap32[r5 + numDefineNeg32];
                r2 = (r2 + -1) | 0;
                r6 = (r6 + 1) | 0;
                heapClassInst.heap32[r5 + numDefineNeg32] = r6;
                if (!(r2 != 0)) {
                    break repeat3;
                }
            }
            r2 = heapClassInst.heap32[r1 + numDefine279];
        }
        r2 = (r2 + -1) | 0;
        repeat7: do {
            if (!(r2 < 0)) {
                repeat8: while (true) {
                    r3 = r2;
                    r2 = (r3 * numDefine69) | 0;
                    r2 = r2 << numDefine2;
                    r2 = (r0 + r2) | 0;
                    r2 = r2 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r2 + numDefine21];
                    f1 = heapClassInst.heapFloat[r1 + numDefine280];
                    if (f0 <= f1) {
                        f2 = heapClassInst.heapFloat[r2 + numDefine17];
                        f3 = heapClassInst.heapFloat[r2 + numDefine18];
                        f4 = heapClassInst.heapFloat[r2 + numDefine19];
                        f5 = heapClassInst.heapFloat[r2 + numDefine13];
                        f2 = f2 * f0;
                        f6 = heapClassInst.heapFloat[r2 + numDefine14];
                        f3 = f3 * f0;
                        f7 = heapClassInst.heapFloat[r2 + numDefine9];
                        f2 = f5 - f2;
                        f5 = heapClassInst.heapFloat[r2 + numDefine10];
                        f3 = f6 - f3;
                        f6 = heapClassInst.heapFloat[r2 + numDefine15];
                        f0 = f4 * f0;
                        f2 = f7 - f2;
                        f3 = f5 - f3;
                        f4 = heapClassInst.heapFloat[r2 + numDefine11];
                        f0 = f6 - f0;
                        f0 = f4 - f0;
                        f2 = f2 * f2;
                        f3 = f3 * f3;
                        f2 = f2 + f3;
                        f0 = f0 * f0;
                        f1 = f1 * f1;
                        f0 = f2 + f0;
                        if (!(f1 >= f0)) {
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r3;
                            zn20btPersistentManifold18removeContactPointEi(i7);
                        }
                    } else {
                        heapClassInst.heap32[g0] = r0;
                        heapClassInst.heap32[g0 + 1] = r3;
                        zn20btPersistentManifold18removeContactPointEi(i7);
                    }
                    r2 = (r3 + -1) | 0;
                    if (r3 != 0) {
                        continue repeat8;
                    } else {
                        break repeat7;
                    }
                }
            }
        } while (false);
        return;
    }

    public static void zn25btTriangleRaycastCallback15processTriangleEP9btVector3ii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg56;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r0 = r0 >> numDefine2;
        f0 = heapClassInst.heapFloat[r0 + numDefine6];
        f1 = heapClassInst.heapFloat[r0 + numDefine2];
        f2 = heapClassInst.heapFloat[r0 + numDefine10];
        f3 = heapClassInst.heapFloat[r0 + numDefine5];
        f4 = heapClassInst.heapFloat[r0 + 1];
        f5 = heapClassInst.heapFloat[r0 + numDefine9];
        f6 = heapClassInst.heapFloat[r0 + numDefine4];
        f7 = heapClassInst.heapFloat[r0];
        f8 = heapClassInst.heapFloat[r0 + numDefine8];
        f9 = f3 - f4;
        f10 = f2 - f1;
        f11 = f0 - f1;
        f12 = f5 - f4;
        f13 = f8 - f7;
        f14 = f6 - f7;
        f15 = f9 * f10;
        f16 = f11 * f12;
        f15 = f15 - f16;
        r0 = sp + numDefineNeg32;
        f11 = f11 * f13;
        f10 = f14 * f10;
        f10 = f11 - f10;
        r1 = r0 >> numDefine2;
        heapClassInst.heapFloat[fp + numDefineNeg8] = f15;
        f11 = f14 * f12;
        f9 = f9 * f13;
        f9 = f11 - f9;
        heapClassInst.heapFloat[r1 + 1] = f10;
        r2 = heapClassInst.heap32[fp];
        heapClassInst.heapFloat[r1 + numDefine2] = f9;
        r3 = r2 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine3] = 0;
        f11 = heapClassInst.heapFloat[r3 + 1];
        f12 = heapClassInst.heapFloat[r3 + numDefine2];
        f13 = heapClassInst.heapFloat[r3 + numDefine5];
        f14 = heapClassInst.heapFloat[r3 + numDefine6];
        f16 = heapClassInst.heapFloat[r3 + numDefine3];
        f17 = heapClassInst.heapFloat[r3 + numDefine7];
        f18 = f15 * f11;
        f19 = f10 * f12;
        f20 = f15 * f13;
        f21 = f10 * f14;
        f22 = f7 * f15;
        f23 = f4 * f10;
        f18 = f18 + f19;
        f19 = f9 * f16;
        f20 = f20 + f21;
        f21 = f9 * f17;
        f22 = f22 + f23;
        f23 = f1 * f9;
        f18 = f18 + f19;
        f19 = f22 + f23;
        f20 = f20 + f21;
        f18 = f18 - f19;
        f19 = f20 - f19;
        f20 = f18 * f19;
        f21 = 0;
        repeat1: do {
            if (!(f20 >= f21)) {
                r4 = heapClassInst.heap32[r3 + numDefine9];
                r4 = r4 & 1;
                if (!(r4 == 0)) {
                    if (f18 > f21) {
                        break repeat1;
                    }
                }
                f19 = f18 - f19;
                f19 = f18 / f19;
                f20 = heapClassInst.heapFloat[r3 + numDefine10];
                if (!(f20 <= f19)) {
                    f20 = 1;
                    f22 = f20 - f19;
                    f16 = f16 * f22;
                    f17 = f17 * f19;
                    f12 = f12 * f22;
                    f14 = f14 * f19;
                    f11 = f11 * f22;
                    f13 = f13 * f19;
                    f16 = f16 + f17;
                    f12 = f12 + f14;
                    f11 = f11 + f13;
                    f1 = f1 - f16;
                    f3 = f3 - f12;
                    f7 = f7 - f11;
                    f0 = f0 - f16;
                    f4 = f4 - f12;
                    f6 = f6 - f11;
                    f13 = f15 * f15;
                    f14 = f10 * f10;
                    f17 = f4 * f0;
                    f22 = f1 * f3;
                    f23 = f1 * f6;
                    f24 = f7 * f0;
                    f13 = f13 + f14;
                    f14 = f9 * f9;
                    f17 = f17 - f22;
                    f22 = f23 - f24;
                    f13 = f13 + f14;
                    f14 = (float) -numDefineFloat9165;
                    f23 = f7 * f3;
                    f24 = f4 * f6;
                    f23 = f23 - f24;
                    f14 = f13 * f14;
                    f17 = f17 * f15;
                    f22 = f22 * f10;
                    f17 = f17 + f22;
                    f22 = f23 * f9;
                    f17 = f17 + f22;
                    if (!(f17 < f14)) {
                        f2 = f2 - f16;
                        f5 = f5 - f12;
                        f8 = f8 - f11;
                        f11 = f3 * f2;
                        f12 = f0 * f5;
                        f0 = f0 * f8;
                        f16 = f6 * f2;
                        f11 = f11 - f12;
                        f0 = f0 - f16;
                        f6 = f6 * f5;
                        f3 = f3 * f8;
                        f11 = f11 * f15;
                        f0 = f0 * f10;
                        f3 = f6 - f3;
                        f0 = f11 + f0;
                        f3 = f3 * f9;
                        f0 = f0 + f3;
                        if (!(f0 < f14)) {
                            f0 = f5 * f1;
                            f3 = f2 * f4;
                            f2 = f2 * f7;
                            f1 = f8 * f1;
                            f0 = f0 - f3;
                            f1 = f2 - f1;
                            f2 = f8 * f4;
                            f3 = f5 * f7;
                            f0 = f0 * f15;
                            f1 = f1 * f10;
                            f2 = f2 - f3;
                            f0 = f0 + f1;
                            f1 = f2 * f9;
                            f0 = f0 + f1;
                            if (!(f0 < f14)) {
                                r4 = heapClassInst.heap32[fp + numDefine2];
                                r5 = heapClassInst.heap32[fp + numDefine3];
                                heapClassInst.heapFloat[g0] = f13;
                                sqrtf(i7);
                                f0 = (float) (f20 / commonVariable.fg0);
                                f1 = heapClassInst.heapFloat[fp + numDefineNeg8];
                                f1 = f1 * f0;
                                heapClassInst.heapFloat[fp + numDefineNeg8] = f1;
                                f2 = heapClassInst.heapFloat[r1 + 1];
                                f2 = f2 * f0;
                                heapClassInst.heapFloat[r1 + 1] = f2;
                                f3 = heapClassInst.heapFloat[r1 + numDefine2];
                                f0 = f3 * f0;
                                heapClassInst.heapFloat[r1 + numDefine2] = f0;
                                r1 = heapClassInst.heap32[r3];
                                r1 = r1 >> numDefine2;
                                r1 = heapClassInst.heap32[r1 + numDefine3];
                                r6 = heapClassInst.heap32[r3 + numDefine9];
                                r6 = r6 & numDefine2;
                                if (r6 != 0) {
                                    label = numDefine9;
                                } else {
                                    if (f18 > f21) {
                                        label = numDefine10;
                                    } else {
                                        label = numDefine9;
                                    }
                                }
                                if (label == numDefine9) {
                                    r0 = sp + numDefineNeg16;
                                    f1 = -f1;
                                    r6 = r0 >> numDefine2;
                                    f2 = -f2;
                                    heapClassInst.heapFloat[fp + numDefineNeg4] = f1;
                                    f0 = -f0;
                                    heapClassInst.heapFloat[r6 + 1] = f2;
                                    heapClassInst.heapFloat[r6 + numDefine2] = f0;
                                    heapClassInst.heap32[r6 + numDefine3] = 0;
                                }
                                heapClassInst.heap32[g0] = r2;
                                heapClassInst.heap32[g0 + 1] = r0;
                                heapClassInst.heapFloat[g0 + numDefine2] = f19;
                                heapClassInst.heap32[g0 + numDefine3] = r4;
                                heapClassInst.heap32[g0 + numDefine4] = r5;
                                functionTable.get(r1 >> numDefine2).accept(i7);
                                heapClassInst.heapFloat[r3 + numDefine10] = (float) commonVariable.fg0;
                            }
                        }
                    }
                }
            }
        } while (false);
        return;
    }

    public static void zn28btTriangleConvexcastCallbackC2EPK13btConvexShapeRK11btTransformS5S5F(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv28btTriangleConvexcastCallback;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        r2 = heapClassInst.heap32[fp + numDefine2];
        r3 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[r0] = r1;
        r1 = r2 >> numDefine2;
        heapClassInst.heap32[r0 + 1] = r3;
        heapClassInst.heap32[r0 + numDefine2] = heapClassInst.heap32[r1];
        heapClassInst.heap32[r0 + numDefine3] = heapClassInst.heap32[r1 + 1];
        heapClassInst.heap32[r0 + numDefine4] = heapClassInst.heap32[r1 + numDefine2];
        heapClassInst.heap32[r0 + numDefine5] = heapClassInst.heap32[r1 + numDefine3];
        heapClassInst.heap32[r0 + numDefine6] = heapClassInst.heap32[r1 + numDefine4];
        heapClassInst.heap32[r0 + numDefine7] = heapClassInst.heap32[r1 + numDefine5];
        heapClassInst.heap32[r0 + numDefine8] = heapClassInst.heap32[r1 + numDefine6];
        heapClassInst.heap32[r0 + numDefine9] = heapClassInst.heap32[r1 + numDefine7];
        heapClassInst.heap32[r0 + numDefine10] = heapClassInst.heap32[r1 + numDefine8];
        heapClassInst.heap32[r0 + numDefine11] = heapClassInst.heap32[r1 + numDefine9];
        heapClassInst.heap32[r0 + numDefine12] = heapClassInst.heap32[r1 + numDefine10];
        heapClassInst.heap32[r0 + numDefine13] = heapClassInst.heap32[r1 + numDefine11];
        heapClassInst.heap32[r0 + numDefine14] = heapClassInst.heap32[r1 + numDefine12];
        heapClassInst.heap32[r0 + numDefine15] = heapClassInst.heap32[r1 + numDefine13];
        r2 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heap32[r0 + numDefine16] = heapClassInst.heap32[r1 + numDefine14];
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r0 + numDefine17] = heapClassInst.heap32[r1 + numDefine15];
        heapClassInst.heap32[r0 + numDefine18] = heapClassInst.heap32[r2];
        heapClassInst.heap32[r0 + numDefine19] = heapClassInst.heap32[r2 + 1];
        heapClassInst.heap32[r0 + numDefine20] = heapClassInst.heap32[r2 + numDefine2];
        heapClassInst.heap32[r0 + numDefine21] = heapClassInst.heap32[r2 + numDefine3];
        heapClassInst.heap32[r0 + numDefine22] = heapClassInst.heap32[r2 + numDefine4];
        heapClassInst.heap32[r0 + numDefine23] = heapClassInst.heap32[r2 + numDefine5];
        heapClassInst.heap32[r0 + numDefine24] = heapClassInst.heap32[r2 + numDefine6];
        heapClassInst.heap32[r0 + numDefine25] = heapClassInst.heap32[r2 + numDefine7];
        heapClassInst.heap32[r0 + numDefine26] = heapClassInst.heap32[r2 + numDefine8];
        heapClassInst.heap32[r0 + numDefine27] = heapClassInst.heap32[r2 + numDefine9];
        heapClassInst.heap32[r0 + numDefine28] = heapClassInst.heap32[r2 + numDefine10];
        heapClassInst.heap32[r0 + numDefine29] = heapClassInst.heap32[r2 + numDefine11];
        heapClassInst.heap32[r0 + numDefine30] = heapClassInst.heap32[r2 + numDefine12];
        heapClassInst.heap32[r0 + numDefine31] = heapClassInst.heap32[r2 + numDefine13];
        r1 = heapClassInst.heap32[fp + numDefine4];
        heapClassInst.heap32[r0 + numDefine32] = heapClassInst.heap32[r2 + numDefine14];
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r0 + numDefine33] = heapClassInst.heap32[r2 + numDefine15];
        heapClassInst.heap32[r0 + numDefine34] = heapClassInst.heap32[r1];
        heapClassInst.heap32[r0 + numDefine35] = heapClassInst.heap32[r1 + 1];
        heapClassInst.heap32[r0 + numDefine36] = heapClassInst.heap32[r1 + numDefine2];
        heapClassInst.heap32[r0 + numDefine37] = heapClassInst.heap32[r1 + numDefine3];
        heapClassInst.heap32[r0 + numDefine38] = heapClassInst.heap32[r1 + numDefine4];
        heapClassInst.heap32[r0 + numDefine39] = heapClassInst.heap32[r1 + numDefine5];
        heapClassInst.heap32[r0 + numDefine40] = heapClassInst.heap32[r1 + numDefine6];
        heapClassInst.heap32[r0 + numDefine41] = heapClassInst.heap32[r1 + numDefine7];
        heapClassInst.heap32[r0 + numDefine42] = heapClassInst.heap32[r1 + numDefine8];
        heapClassInst.heap32[r0 + numDefine43] = heapClassInst.heap32[r1 + numDefine9];
        heapClassInst.heap32[r0 + numDefine44] = heapClassInst.heap32[r1 + numDefine10];
        heapClassInst.heap32[r0 + numDefine45] = heapClassInst.heap32[r1 + numDefine11];
        heapClassInst.heap32[r0 + numDefine46] = heapClassInst.heap32[r1 + numDefine12];
        heapClassInst.heap32[r0 + numDefine47] = heapClassInst.heap32[r1 + numDefine13];
        heapClassInst.heap32[r0 + numDefine48] = heapClassInst.heap32[r1 + numDefine14];
        heapClassInst.heap32[r0 + numDefine49] = heapClassInst.heap32[r1 + numDefine15];
        heapClassInst.heap32[r0 + numDefine50] = numDefine53216;
        heapClassInst.heap32[r0 + numDefine51] = heapClassInst.heap32[fp + numDefine5];
        return;
    }

    public static void zn28btTriangleConvexcastCallbackD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv18btTriangleCallback;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn28btTriangleConvexcastCallbackD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv18btTriangleCallback;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn28btTriangleConvexcastCallback15processTriangleEP9btVector3ii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg696;
        int g0 = i7 >> numDefine2;
        r0 = sp + numDefineNeg104;
        r1 = r0 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine2] = 0;
        heapClassInst.heap32[r1 + numDefine3] = numDefine53216;
        heapClassInst.heap32[r1 + numDefine4] = numDefine53216;
        r2 = ztv15btTriangleShape;
        heapClassInst.heap32[r1 + numDefine5] = numDefine53216;
        r2 = (r2 + numDefine8) | 0;
        heapClassInst.heap32[r1 + numDefine6] = 0;
        r3 = heapClassInst.heap32[fp + 1];
        heapClassInst.heap32[fp + numDefineNeg26] = r2;
        r2 = r3 >> numDefine2;
        heapClassInst.heap32[r1 + 1] = 1;
        heapClassInst.heap32[r1 + numDefine13] = heapClassInst.heap32[r2];
        heapClassInst.heap32[r1 + numDefine14] = heapClassInst.heap32[r2 + 1];
        heapClassInst.heap32[r1 + numDefine15] = heapClassInst.heap32[r2 + numDefine2];
        heapClassInst.heap32[r1 + numDefine16] = heapClassInst.heap32[r2 + numDefine3];
        heapClassInst.heap32[r1 + numDefine17] = heapClassInst.heap32[r2 + numDefine4];
        heapClassInst.heap32[r1 + numDefine18] = heapClassInst.heap32[r2 + numDefine5];
        heapClassInst.heap32[r1 + numDefine19] = heapClassInst.heap32[r2 + numDefine6];
        heapClassInst.heap32[r1 + numDefine20] = heapClassInst.heap32[r2 + numDefine7];
        heapClassInst.heap32[r1 + numDefine21] = heapClassInst.heap32[r2 + numDefine8];
        heapClassInst.heap32[r1 + numDefine22] = heapClassInst.heap32[r2 + numDefine9];
        r3 = heapClassInst.heap32[fp];
        heapClassInst.heap32[r1 + numDefine23] = heapClassInst.heap32[r2 + numDefine10];
        r4 = sp + numDefineNeg464;
        r5 = r3 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine24] = heapClassInst.heap32[r2 + numDefine11];
        r2 = r4 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine11] = heapClassInst.heap32[r5 + numDefine51];
        r1 = ztv30btGjkEpaPenetrationDepthSolver;
        r6 = 0;
        heapClassInst.heap32[r2 + numDefine77] = numDefine67991;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap8[sp + numDefineNeg132] = (byte) r6;
        heapClassInst.heap32[fp + numDefineNeg118] = r1;
        r1 = ztv27btContinuousConvexCollision;
        r2 = sp + numDefineNeg496;
        r6 = heapClassInst.heap32[r5 + 1];
        r1 = (r1 + numDefine8) | 0;
        r7 = r2 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg124] = r1;
        r1 = sp + numDefineNeg472;
        heapClassInst.heap32[r7 + 1] = r4;
        heapClassInst.heap32[r7 + numDefine2] = r1;
        r1 = ztvn12btConvexCast10CastResultE;
        heapClassInst.heap32[r7 + numDefine3] = r6;
        r4 = sp + numDefineNeg672;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r7 + numDefine4] = r0;
        r0 = r4 >> numDefine2;
        heapClassInst.heap32[fp + numDefineNeg168] = r1;
        heapClassInst.heap32[r0 + numDefine42] = 0;
        heapClassInst.heap32[r0 + numDefine43] = 0;
        heapClassInst.heap32[r0 + numDefine41] = numDefine53216;
        r1 = (r3 + numDefine136) | 0;
        r6 = (r3 + numDefine8) | 0;
        r7 = (r3 + numDefine72) | 0;
        heapClassInst.heap32[g0] = r2;
        heapClassInst.heap32[g0 + 1] = r6;
        heapClassInst.heap32[g0 + numDefine2] = r7;
        heapClassInst.heap32[g0 + numDefine3] = r1;
        heapClassInst.heap32[g0 + numDefine4] = r1;
        heapClassInst.heap32[g0 + numDefine5] = r4;
        zn27btContinuousConvexCollisionTransformConvexCast10CastResultE(i7);
        r1 = commonVariable.rg0;
        if (!(r1 == 0)) {
            f0 = heapClassInst.heapFloat[r0 + numDefine33];
            f1 = heapClassInst.heapFloat[r0 + numDefine34];
            f2 = heapClassInst.heapFloat[r0 + numDefine35];
            f0 = f0 * f0;
            f1 = f1 * f1;
            f0 = f0 + f1;
            f1 = f2 * f2;
            f0 = f0 + f1;
            f1 = (float) numDefineFloat9165;
            if (!(f0 <= f1)) {
                f1 = heapClassInst.heapFloat[r0 + numDefine41];
                f2 = heapClassInst.heapFloat[r5 + numDefine50];
                if (!(f1 >= f2)) {
                    r1 = heapClassInst.heap32[fp + numDefine2];
                    r2 = heapClassInst.heap32[fp + numDefine3];
                    heapClassInst.heapFloat[g0] = f0;
                    sqrtf(i7);
                    f1 = 1;
                    f0 = (float) (f1 / commonVariable.fg0);
                    f1 = heapClassInst.heapFloat[r0 + numDefine33];
                    f1 = f1 * f0;
                    heapClassInst.heapFloat[r0 + numDefine33] = f1;
                    f1 = heapClassInst.heapFloat[r0 + numDefine34];
                    f1 = f1 * f0;
                    heapClassInst.heapFloat[r0 + numDefine34] = f1;
                    f1 = heapClassInst.heapFloat[r0 + numDefine35];
                    f0 = f1 * f0;
                    heapClassInst.heapFloat[r0 + numDefine35] = f0;
                    r5 = heapClassInst.heap32[r5];
                    r5 = r5 >> numDefine2;
                    r5 = heapClassInst.heap32[r5 + numDefine3];
                    f0 = heapClassInst.heapFloat[r0 + numDefine41];
                    r0 = (r4 + numDefine132) | 0;
                    r4 = (r4 + numDefine148) | 0;
                    heapClassInst.heap32[g0] = r3;
                    heapClassInst.heap32[g0 + 1] = r0;
                    heapClassInst.heap32[g0 + numDefine2] = r4;
                    heapClassInst.heapFloat[g0 + numDefine3] = f0;
                    heapClassInst.heap32[g0 + numDefine4] = r1;
                    heapClassInst.heap32[g0 + numDefine5] = r2;
                    functionTable.get(r5 >> numDefine2).accept(i7);
                }
            }
        }
        return;
    }

    public static void zn22btSubsimplexConvexCastD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv12btConvexCast;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn22btSubsimplexConvexCastD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv12btConvexCast;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn22btSubsimplexConvexCastTimeTransform(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        float f30 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg240;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[r0 + 1];
        r2 = 0;
        r3 = r1 >> numDefine2;
        heapClassInst.heap8[r1 + numDefine312] = (byte) r2;
        r4 = 1;
        heapClassInst.heap32[r3] = 0;
        heapClassInst.heap8[r1 + numDefine356] = (byte) r4;
        heapClassInst.heap32[r3 + numDefine73] = numDefine44395;
        heapClassInst.heap32[r3 + numDefine74] = numDefine44395;
        heapClassInst.heap32[r3 + numDefine75] = numDefine44395;
        heapClassInst.heap32[r3 + numDefine76] = 0;
        heapClassInst.heap8[r1 + numDefine352] = (byte) r2;
        heapClassInst.heap32[r3 + numDefine84] = 0;
        heapClassInst.heap32[r3 + numDefine85] = 0;
        heapClassInst.heap32[r3 + numDefine86] = 0;
        heapClassInst.heap32[r3 + numDefine87] = 0;
        r3 = heapClassInst.heapU8[r1 + numDefine332];
        r5 = heapClassInst.heap32[fp + 1];
        r6 = heapClassInst.heap32[fp + numDefine2];
        r7 = heapClassInst.heap32[fp + numDefine4];
        r8 = heapClassInst.heap32[fp + numDefine3];
        r3 = r3 & numDefine240;
        heapClassInst.heap8[r1 + numDefine332] = (byte) r3;
        r1 = r5 >> numDefine2;
        r3 = r8 >> numDefine2;
        r5 = r6 >> numDefine2;
        r6 = r7 >> numDefine2;
        f0 = heapClassInst.heapFloat[r1 + numDefine12];
        f1 = heapClassInst.heapFloat[r5 + numDefine12];
        f2 = heapClassInst.heapFloat[r3 + numDefine12];
        f3 = heapClassInst.heapFloat[r6 + numDefine12];
        f4 = heapClassInst.heapFloat[r1 + numDefine13];
        f5 = heapClassInst.heapFloat[r5 + numDefine13];
        f6 = heapClassInst.heapFloat[r3 + numDefine13];
        f7 = heapClassInst.heapFloat[r6 + numDefine13];
        r7 = heapClassInst.heap32[r0 + numDefine2];
        f1 = f1 - f0;
        f3 = f3 - f2;
        f1 = f1 - f3;
        heapClassInst.heapFloat[fp + numDefineNeg50] = f1;
        f3 = heapClassInst.heapFloat[r1 + numDefine14];
        f8 = heapClassInst.heapFloat[r5 + numDefine14];
        f9 = heapClassInst.heapFloat[r3 + numDefine14];
        f10 = heapClassInst.heapFloat[r6 + numDefine14];
        r8 = r7 >> numDefine2;
        f5 = f5 - f4;
        f7 = f7 - f6;
        f5 = f5 - f7;
        heapClassInst.heapFloat[fp + numDefineNeg51] = f5;
        f7 = heapClassInst.heapFloat[r1 + numDefine4];
        heapClassInst.heapFloat[fp + numDefineNeg42] = f7;
        f11 = heapClassInst.heapFloat[r1];
        heapClassInst.heapFloat[fp + numDefineNeg43] = f11;
        f12 = -f1;
        r8 = heapClassInst.heap32[r8];
        f8 = f8 - f3;
        f10 = f10 - f9;
        f13 = heapClassInst.heapFloat[r1 + 1];
        heapClassInst.heapFloat[fp + numDefineNeg44] = f13;
        f14 = heapClassInst.heapFloat[r1 + numDefine5];
        heapClassInst.heapFloat[fp + numDefineNeg45] = f14;
        r8 = r8 >> numDefine2;
        f8 = f8 - f10;
        heapClassInst.heapFloat[fp + numDefineNeg52] = f8;
        f10 = heapClassInst.heapFloat[r1 + numDefine8];
        heapClassInst.heapFloat[fp + numDefineNeg46] = f10;
        f11 = f11 * f12;
        f7 = f7 * f5;
        f15 = heapClassInst.heapFloat[r1 + numDefine2];
        heapClassInst.heapFloat[fp + numDefineNeg47] = f15;
        f16 = heapClassInst.heapFloat[r1 + numDefine6];
        f17 = heapClassInst.heapFloat[r1 + numDefine9];
        f18 = heapClassInst.heapFloat[r1 + numDefine10];
        f19 = heapClassInst.heapFloat[r3];
        heapClassInst.heapFloat[fp + numDefineNeg33] = f19;
        f19 = heapClassInst.heapFloat[r3 + 1];
        heapClassInst.heapFloat[fp + numDefineNeg34] = f19;
        f19 = heapClassInst.heapFloat[r3 + numDefine2];
        heapClassInst.heapFloat[fp + numDefineNeg35] = f19;
        f19 = heapClassInst.heapFloat[r3 + numDefine4];
        heapClassInst.heapFloat[fp + numDefineNeg36] = f19;
        f19 = heapClassInst.heapFloat[r3 + numDefine5];
        heapClassInst.heapFloat[fp + numDefineNeg37] = f19;
        f19 = heapClassInst.heapFloat[r3 + numDefine6];
        heapClassInst.heapFloat[fp + numDefineNeg38] = f19;
        f19 = heapClassInst.heapFloat[r3 + numDefine8];
        heapClassInst.heapFloat[fp + numDefineNeg39] = f19;
        f19 = heapClassInst.heapFloat[r3 + numDefine9];
        heapClassInst.heapFloat[fp + numDefineNeg40] = f19;
        f19 = heapClassInst.heapFloat[r3 + numDefine10];
        heapClassInst.heapFloat[fp + numDefineNeg41] = f19;
        r8 = heapClassInst.heap32[r8 + numDefine15];
        f13 = f13 * f12;
        f14 = f14 * f5;
        f7 = f11 - f7;
        f10 = f10 * f8;
        r9 = sp + numDefineNeg112;
        f11 = f15 * f12;
        f12 = f16 * f5;
        f13 = f13 - f14;
        f14 = f17 * f8;
        f7 = f7 - f10;
        r10 = r9 >> numDefine2;
        f10 = f11 - f12;
        f11 = f18 * f8;
        f12 = f13 - f14;
        heapClassInst.heapFloat[fp + numDefineNeg28] = f7;
        f7 = f10 - f11;
        heapClassInst.heapFloat[r10 + 1] = f12;
        heapClassInst.heapFloat[r10 + numDefine2] = f7;
        heapClassInst.heap32[r10 + numDefine3] = 0;
        r10 = sp + numDefineNeg128;
        heapClassInst.heap32[g0] = r10;
        heapClassInst.heap32[g0 + 1] = r7;
        heapClassInst.heap32[g0 + numDefine2] = r9;
        functionTable.get(r8 >> numDefine2).accept(i7);
        r7 = heapClassInst.heap32[r0 + numDefine3];
        r8 = r7 >> numDefine2;
        r8 = heapClassInst.heap32[r8];
        f7 = heapClassInst.heapFloat[r3];
        f10 = heapClassInst.heapFloat[r3 + numDefine4];
        r9 = r10 >> numDefine2;
        r8 = r8 >> numDefine2;
        f11 = heapClassInst.heapFloat[r3 + 1];
        f12 = heapClassInst.heapFloat[r3 + numDefine5];
        f13 = heapClassInst.heapFloat[r3 + numDefine8];
        f7 = f7 * f1;
        f10 = f10 * f5;
        f14 = heapClassInst.heapFloat[r3 + numDefine2];
        f15 = heapClassInst.heapFloat[r3 + numDefine6];
        f19 = heapClassInst.heapFloat[r3 + numDefine10];
        f20 = heapClassInst.heapFloat[r3 + numDefine9];
        r8 = heapClassInst.heap32[r8 + numDefine15];
        f11 = f11 * f1;
        f12 = f12 * f5;
        f7 = f7 + f10;
        f10 = f13 * f8;
        f13 = heapClassInst.heapFloat[r1];
        heapClassInst.heapFloat[fp + numDefineNeg48] = f13;
        f21 = heapClassInst.heapFloat[fp + numDefineNeg32];
        f22 = heapClassInst.heapFloat[r1 + numDefine4];
        f23 = heapClassInst.heapFloat[r1 + numDefine8];
        heapClassInst.heapFloat[fp + numDefineNeg49] = f23;
        f24 = heapClassInst.heapFloat[r1 + 1];
        f25 = heapClassInst.heapFloat[r9 + 1];
        f26 = heapClassInst.heapFloat[r1 + numDefine5];
        f27 = heapClassInst.heapFloat[r1 + numDefine9];
        f28 = heapClassInst.heapFloat[r1 + numDefine2];
        f29 = heapClassInst.heapFloat[r9 + numDefine2];
        f30 = heapClassInst.heapFloat[r1 + numDefine6];
        f13 = heapClassInst.heapFloat[r1 + numDefine10];
        heapClassInst.heapFloat[fp + numDefineNeg54] = f13;
        f13 = heapClassInst.heapFloat[r1 + numDefine12];
        heapClassInst.heapFloat[fp + numDefineNeg53] = f13;
        f13 = heapClassInst.heapFloat[r1 + numDefine13];
        heapClassInst.heapFloat[fp + numDefineNeg56] = f13;
        f13 = heapClassInst.heapFloat[r1 + numDefine14];
        heapClassInst.heapFloat[fp + numDefineNeg55] = f13;
        r9 = sp + numDefineNeg80;
        f1 = f14 * f1;
        f5 = f15 * f5;
        f11 = f11 + f12;
        f12 = f20 * f8;
        f7 = f7 + f10;
        r10 = r9 >> numDefine2;
        f1 = f1 + f5;
        f5 = f19 * f8;
        f8 = f11 + f12;
        heapClassInst.heapFloat[fp + numDefineNeg20] = f7;
        f1 = f1 + f5;
        heapClassInst.heapFloat[r10 + 1] = f8;
        heapClassInst.heapFloat[r10 + numDefine2] = f1;
        heapClassInst.heap32[r10 + numDefine3] = 0;
        r10 = sp + numDefineNeg96;
        heapClassInst.heap32[g0] = r10;
        heapClassInst.heap32[g0 + 1] = r7;
        heapClassInst.heap32[g0 + numDefine2] = r9;
        functionTable.get(r8 >> numDefine2).accept(i7);
        r7 = r10 >> numDefine2;
        f1 = heapClassInst.heapFloat[r3];
        f5 = heapClassInst.heapFloat[fp + numDefineNeg24];
        f7 = heapClassInst.heapFloat[r3 + numDefine4];
        f8 = heapClassInst.heapFloat[r3 + 1];
        f10 = heapClassInst.heapFloat[r7 + 1];
        f11 = heapClassInst.heapFloat[r3 + numDefine5];
        f12 = heapClassInst.heapFloat[r3 + numDefine8];
        f14 = heapClassInst.heapFloat[r3 + numDefine9];
        f13 = heapClassInst.heapFloat[fp + numDefineNeg48];
        f13 = f13 * f21;
        f15 = f24 * f25;
        f1 = f1 * f5;
        f8 = f8 * f10;
        f19 = heapClassInst.heapFloat[r3 + numDefine2];
        f20 = heapClassInst.heapFloat[r7 + numDefine2];
        f24 = heapClassInst.heapFloat[r3 + numDefine6];
        f22 = f22 * f21;
        f26 = f26 * f25;
        f7 = f7 * f5;
        f11 = f11 * f10;
        f23 = heapClassInst.heapFloat[r3 + numDefine10];
        f13 = f13 + f15;
        f15 = f28 * f29;
        f1 = f1 + f8;
        f8 = f19 * f20;
        f19 = f22 + f26;
        f22 = f30 * f29;
        f7 = f7 + f11;
        f11 = f24 * f20;
        f24 = heapClassInst.heapFloat[fp + numDefineNeg49];
        f21 = f24 * f21;
        f24 = f27 * f25;
        f5 = f12 * f5;
        f10 = f14 * f10;
        f12 = f13 + f15;
        f13 = f19 + f22;
        f1 = f1 + f8;
        f8 = heapClassInst.heapFloat[r3 + numDefine12];
        f7 = f7 + f11;
        f11 = heapClassInst.heapFloat[r3 + numDefine13];
        f14 = f21 + f24;
        f15 = heapClassInst.heapFloat[fp + numDefineNeg54];
        f15 = f15 * f29;
        f5 = f5 + f10;
        f10 = f23 * f20;
        f14 = f14 + f15;
        f15 = heapClassInst.heapFloat[fp + numDefineNeg53];
        f12 = f12 + f15;
        f1 = f1 + f8;
        f8 = heapClassInst.heapFloat[fp + numDefineNeg56];
        f8 = f13 + f8;
        f7 = f7 + f11;
        f5 = f5 + f10;
        f10 = heapClassInst.heapFloat[r3 + numDefine14];
        f1 = f12 - f1;
        f7 = f8 - f7;
        f13 = heapClassInst.heapFloat[fp + numDefineNeg55];
        f8 = f14 + f13;
        f5 = f5 + f10;
        f5 = f8 - f5;
        f8 = f1 * f1;
        f10 = f7 * f7;
        f8 = f8 + f10;
        f10 = f5 * f5;
        r7 = heapClassInst.heap32[fp + numDefine5];
        f8 = f8 + f10;
        r8 = numDefineNeg33;
        f10 = 0;
        heapClassInst.heapFloat[fp + numDefineNeg48] = f10;
        heapClassInst.heapFloat[fp + numDefineNeg49] = f10;
        f11 = f10;
        repeat1: while (true) {
            f12 = (float) numDefineFloat9165;
            if (f8 <= f12) {
                label = numDefine19;
                break repeat1;
            } else {
                r8 = (r8 + 1) | 0;
                if (r8 != 0) {
                    r9 = heapClassInst.heap32[r0 + numDefine2];
                    r10 = r9 >> numDefine2;
                    r10 = heapClassInst.heap32[r10];
                    f8 = -f1;
                    r10 = r10 >> numDefine2;
                    f12 = heapClassInst.heapFloat[fp + numDefineNeg43];
                    f12 = f12 * f8;
                    f13 = heapClassInst.heapFloat[fp + numDefineNeg42];
                    f13 = f13 * f7;
                    r10 = heapClassInst.heap32[r10 + numDefine15];
                    f14 = heapClassInst.heapFloat[fp + numDefineNeg44];
                    f14 = f14 * f8;
                    f15 = heapClassInst.heapFloat[fp + numDefineNeg45];
                    f15 = f15 * f7;
                    f12 = f12 - f13;
                    f13 = heapClassInst.heapFloat[fp + numDefineNeg46];
                    f13 = f13 * f5;
                    r11 = sp + numDefineNeg48;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg47];
                    f8 = f19 * f8;
                    f19 = f16 * f7;
                    f14 = f14 - f15;
                    f15 = f17 * f5;
                    f12 = f12 - f13;
                    r12 = r11 >> numDefine2;
                    f8 = f8 - f19;
                    f13 = f18 * f5;
                    f14 = f14 - f15;
                    heapClassInst.heapFloat[fp + numDefineNeg12] = f12;
                    f8 = f8 - f13;
                    heapClassInst.heapFloat[r12 + 1] = f14;
                    heapClassInst.heapFloat[r12 + numDefine2] = f8;
                    heapClassInst.heap32[r12 + numDefine3] = 0;
                    r12 = sp + numDefineNeg64;
                    heapClassInst.heap32[g0] = r12;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r11;
                    functionTable.get(r10 >> numDefine2).accept(i7);
                    r9 = heapClassInst.heap32[r0 + numDefine3];
                    r10 = r9 >> numDefine2;
                    r10 = heapClassInst.heap32[r10];
                    r11 = r12 >> numDefine2;
                    r10 = r10 >> numDefine2;
                    f8 = heapClassInst.heapFloat[fp + numDefineNeg33];
                    f8 = f8 * f1;
                    f12 = heapClassInst.heapFloat[fp + numDefineNeg36];
                    f12 = f12 * f7;
                    f13 = heapClassInst.heapFloat[fp + numDefineNeg16];
                    f14 = heapClassInst.heapFloat[r11 + 1];
                    f15 = heapClassInst.heapFloat[r11 + numDefine2];
                    r10 = heapClassInst.heap32[r10 + numDefine15];
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg34];
                    f19 = f19 * f1;
                    f20 = heapClassInst.heapFloat[fp + numDefineNeg37];
                    f20 = f20 * f7;
                    f8 = f8 + f12;
                    f12 = heapClassInst.heapFloat[fp + numDefineNeg39];
                    f12 = f12 * f5;
                    r11 = sp + numDefineNeg16;
                    f21 = heapClassInst.heapFloat[fp + numDefineNeg35];
                    f21 = f21 * f1;
                    f22 = heapClassInst.heapFloat[fp + numDefineNeg38];
                    f22 = f22 * f7;
                    f19 = f19 + f20;
                    f20 = heapClassInst.heapFloat[fp + numDefineNeg40];
                    f20 = f20 * f5;
                    f8 = f8 + f12;
                    r12 = r11 >> numDefine2;
                    f12 = f21 + f22;
                    f21 = heapClassInst.heapFloat[fp + numDefineNeg41];
                    f21 = f21 * f5;
                    f19 = f19 + f20;
                    heapClassInst.heapFloat[fp + numDefineNeg4] = f8;
                    f8 = f12 + f21;
                    heapClassInst.heapFloat[r12 + 1] = f19;
                    heapClassInst.heapFloat[r12 + numDefine2] = f8;
                    heapClassInst.heap32[r12 + numDefine3] = 0;
                    r12 = sp + numDefineNeg32;
                    heapClassInst.heap32[g0] = r12;
                    heapClassInst.heap32[g0 + 1] = r9;
                    heapClassInst.heap32[g0 + numDefine2] = r11;
                    functionTable.get(r10 >> numDefine2).accept(i7);
                    f12 = 1;
                    if (f11 > f12) {
                        label = numDefine24;
                        break repeat1;
                    } else {
                        r9 = r12 >> numDefine2;
                        f8 = heapClassInst.heapFloat[fp + numDefineNeg8];
                        f19 = heapClassInst.heapFloat[r9 + 1];
                        f20 = heapClassInst.heapFloat[r9 + numDefine2];
                        f21 = heapClassInst.heapFloat[fp + numDefineNeg43];
                        f21 = f21 * f13;
                        f22 = heapClassInst.heapFloat[fp + numDefineNeg44];
                        f22 = f22 * f14;
                        f23 = heapClassInst.heapFloat[fp + numDefineNeg33];
                        f23 = f23 * f8;
                        f24 = heapClassInst.heapFloat[fp + numDefineNeg34];
                        f24 = f24 * f19;
                        f25 = heapClassInst.heapFloat[fp + numDefineNeg42];
                        f25 = f25 * f13;
                        f26 = heapClassInst.heapFloat[fp + numDefineNeg45];
                        f26 = f26 * f14;
                        f27 = heapClassInst.heapFloat[fp + numDefineNeg36];
                        f27 = f27 * f8;
                        f28 = heapClassInst.heapFloat[fp + numDefineNeg37];
                        f28 = f28 * f19;
                        f21 = f21 + f22;
                        f22 = heapClassInst.heapFloat[fp + numDefineNeg47];
                        f22 = f22 * f15;
                        f23 = f23 + f24;
                        f24 = heapClassInst.heapFloat[fp + numDefineNeg35];
                        f24 = f24 * f20;
                        f25 = f25 + f26;
                        f26 = f16 * f15;
                        f27 = f27 + f28;
                        f28 = heapClassInst.heapFloat[fp + numDefineNeg38];
                        f28 = f28 * f20;
                        f29 = heapClassInst.heapFloat[fp + numDefineNeg46];
                        f13 = f29 * f13;
                        f14 = f17 * f14;
                        f29 = heapClassInst.heapFloat[fp + numDefineNeg39];
                        f8 = f29 * f8;
                        f29 = heapClassInst.heapFloat[fp + numDefineNeg40];
                        f19 = f29 * f19;
                        f21 = f21 + f22;
                        f22 = f23 + f24;
                        f23 = f25 + f26;
                        f24 = f27 + f28;
                        f13 = f13 + f14;
                        f14 = f18 * f15;
                        f8 = f8 + f19;
                        f15 = heapClassInst.heapFloat[fp + numDefineNeg41];
                        f15 = f15 * f20;
                        f19 = f21 + f0;
                        f20 = f22 + f2;
                        f21 = f23 + f4;
                        f22 = f24 + f6;
                        f13 = f13 + f14;
                        f8 = f8 + f15;
                        f14 = f19 - f20;
                        f15 = f21 - f22;
                        f13 = f13 + f3;
                        f23 = f8 + f9;
                        f24 = f13 - f23;
                        f8 = f1 * f14;
                        f25 = f7 * f15;
                        f8 = f8 + f25;
                        f25 = f5 * f24;
                        f25 = f8 + f25;
                        f8 = 0;
                        if (f25 > f8) {
                            f0 = heapClassInst.heapFloat[fp + numDefineNeg50];
                            f0 = f1 * f0;
                            f2 = heapClassInst.heapFloat[fp + numDefineNeg51];
                            f2 = f7 * f2;
                            f0 = f0 + f2;
                            f2 = heapClassInst.heapFloat[fp + numDefineNeg52];
                            f2 = f5 * f2;
                            f0 = f0 + f2;
                            f2 = (float) numDefineNegFloat4044;
                            if (f0 >= f2) {
                                label = numDefine24;
                                break repeat1;
                            } else {
                                f0 = f25 / f0;
                                f11 = f11 - f0;
                                f0 = heapClassInst.heapFloat[r5 + numDefine12];
                                f2 = heapClassInst.heapFloat[r5 + numDefine13];
                                f3 = heapClassInst.heapFloat[r5 + numDefine14];
                                f4 = heapClassInst.heapFloat[r6 + numDefine12];
                                f6 = heapClassInst.heapFloat[r6 + numDefine13];
                                f9 = heapClassInst.heapFloat[r6 + numDefine14];
                                f10 = heapClassInst.heapFloat[r1 + numDefine12];
                                f12 = f12 - f11;
                                f25 = heapClassInst.heapFloat[r1 + numDefine13];
                                f26 = heapClassInst.heapFloat[r1 + numDefine14];
                                f27 = heapClassInst.heapFloat[r3 + numDefine12];
                                f28 = heapClassInst.heapFloat[r3 + numDefine13];
                                f29 = heapClassInst.heapFloat[r3 + numDefine14];
                                f10 = f10 * f12;
                                f0 = f0 * f11;
                                f25 = f25 * f12;
                                f2 = f2 * f11;
                                f26 = f26 * f12;
                                f3 = f3 * f11;
                                f27 = f27 * f12;
                                f30 = f4 * f11;
                                f28 = f28 * f12;
                                f6 = f6 * f11;
                                f12 = f29 * f12;
                                f9 = f9 * f11;
                                f0 = f10 + f0;
                                f4 = f25 + f2;
                                f3 = f26 + f3;
                                f2 = f27 + f30;
                                f6 = f28 + f6;
                                f9 = f12 + f9;
                                f10 = f1;
                                heapClassInst.heapFloat[fp + numDefineNeg48] = f7;
                                heapClassInst.heapFloat[fp + numDefineNeg49] = f5;
                            }
                        }
                        r9 = heapClassInst.heap32[r0 + 1];
                        r10 = r9 >> numDefine2;
                        r11 = heapClassInst.heap32[r10];
                        repeat10: do {
                            if (r11 > 0) {
                                r12 = numDefineNeg12;
                                f1 = heapClassInst.heapFloat[r10 + numDefine77];
                                r13 = (r12 - r9) | 0;
                                r14 = 0;
                                r15 = r11;
                                r12 = r14;
                                while (true) {
                                    r16 = numDefineNeg8;
                                    r17 = numDefineNeg4;
                                    r16 = (r16 - r13) | 0;
                                    r17 = (r17 - r13) | 0;
                                    r16 = r16 >> numDefine2;
                                    r17 = r17 >> numDefine2;
                                    r18 = (r14 - r13) | 0;
                                    r18 = r18 >> numDefine2;
                                    f5 = heapClassInst.heapFloat[r16];
                                    f7 = heapClassInst.heapFloat[r17];
                                    f5 = f14 - f5;
                                    f7 = f15 - f7;
                                    f12 = heapClassInst.heapFloat[r18];
                                    f12 = f24 - f12;
                                    f5 = f5 * f5;
                                    f7 = f7 * f7;
                                    f5 = f5 + f7;
                                    f7 = f12 * f12;
                                    f5 = f5 + f7;
                                    r15 = (r15 + -1) | 0;
                                    r12 = f5 > f1 ? r12 : r4;
                                    r13 = (r13 + numDefineNeg16) | 0;
                                    if (!(r15 != 0)) {
                                        break repeat10;
                                    }
                                }
                            } else {
                                r12 = r2;
                            }
                        } while (false);
                        f1 = heapClassInst.heapFloat[r10 + numDefine76];
                        if (f1 == f8) {
                            f1 = heapClassInst.heapFloat[r10 + numDefine75];
                            if (!(f24 != f1)) {
                                f1 = heapClassInst.heapFloat[r10 + numDefine74];
                                if (!(f15 != f1)) {
                                    f1 = heapClassInst.heapFloat[r10 + numDefine73];
                                    r12 = f14 != f1 ? r12 : r4;
                                }
                            }
                        }
                        r12 = r12 & numDefine255;
                        if (r12 == 0) {
                            heapClassInst.heapFloat[r10 + numDefine73] = f14;
                            heapClassInst.heapFloat[r10 + numDefine74] = f15;
                            r11 = r11 << numDefine4;
                            heapClassInst.heapFloat[r10 + numDefine75] = f24;
                            r11 = (r9 + r11) | 0;
                            heapClassInst.heap32[r10 + numDefine76] = 0;
                            r11 = r11 >> numDefine2;
                            heapClassInst.heap8[r9 + numDefine356] = (byte) r4;
                            heapClassInst.heapFloat[r11 + 1] = f14;
                            heapClassInst.heapFloat[r11 + numDefine2] = f15;
                            heapClassInst.heapFloat[r11 + numDefine3] = f24;
                            heapClassInst.heap32[r11 + numDefine4] = 0;
                            r11 = heapClassInst.heap32[r10];
                            r11 = r11 << numDefine4;
                            r11 = (r9 + r11) | 0;
                            r11 = r11 >> numDefine2;
                            heapClassInst.heapFloat[r11 + numDefine21] = f19;
                            heapClassInst.heapFloat[r11 + numDefine22] = f21;
                            heapClassInst.heapFloat[r11 + numDefine23] = f13;
                            heapClassInst.heap32[r11 + numDefine24] = 0;
                            r11 = heapClassInst.heap32[r10];
                            r11 = r11 << numDefine4;
                            r9 = (r9 + r11) | 0;
                            r9 = r9 >> numDefine2;
                            heapClassInst.heapFloat[r9 + numDefine41] = f20;
                            heapClassInst.heapFloat[r9 + numDefine42] = f22;
                            heapClassInst.heapFloat[r9 + numDefine43] = f23;
                            heapClassInst.heap32[r9 + numDefine44] = 0;
                            r9 = heapClassInst.heap32[r10];
                            r9 = (r9 + 1) | 0;
                            heapClassInst.heap32[r10] = r9;
                            r9 = heapClassInst.heap32[r0 + 1];
                        }
                        heapClassInst.heap32[g0] = r9;
                        zn22btVoronoiSimplexSolver28updateClosestVectorAndPointsEv(i7);
                        r10 = commonVariable.rg0;
                        r9 = r9 >> numDefine2;
                        f1 = heapClassInst.heapFloat[r9 + numDefine69];
                        f7 = heapClassInst.heapFloat[r9 + numDefine70];
                        f5 = heapClassInst.heapFloat[r9 + numDefine71];
                        if (r10 == 0) {
                            continue repeat1;
                        } else {
                            f8 = f1 * f1;
                            f12 = f7 * f7;
                            f8 = f8 + f12;
                            f12 = f5 * f5;
                            f8 = f8 + f12;
                            continue repeat1;
                        }
                    }
                } else {
                    label = numDefine19;
                    break repeat1;
                }
            }
        }
        if (label == numDefine19) {
            f0 = f10 * f10;
            f7 = heapClassInst.heapFloat[fp + numDefineNeg48];
            f1 = f7 * f7;
            f0 = f0 + f1;
            f1 = heapClassInst.heapFloat[fp + numDefineNeg49];
            f1 = f1 * f1;
            f0 = f0 + f1;
            r1 = r7 >> numDefine2;
            heapClassInst.heapFloat[r1 + numDefine41] = f11;
            f1 = (float) numDefineFloat4044;
            if (f0 < f1) {
                heapClassInst.heap32[r1 + numDefine33] = 0;
                heapClassInst.heap32[r1 + numDefine34] = 0;
                f0 = 0;
                heapClassInst.heap32[r1 + numDefine35] = 0;
                heapClassInst.heap32[r1 + numDefine36] = 0;
                f2 = f0;
                f1 = f0;
            } else {
                heapClassInst.heapFloat[g0] = f0;
                f0 = 1;
                sqrtf(i7);
                f0 = (float) (f0 / commonVariable.fg0);
                f1 = f10 * f0;
                f7 = heapClassInst.heapFloat[fp + numDefineNeg48];
                f2 = f7 * f0;
                heapClassInst.heapFloat[r1 + numDefine33] = f1;
                f11 = heapClassInst.heapFloat[fp + numDefineNeg49];
                f0 = f11 * f0;
                heapClassInst.heapFloat[r1 + numDefine34] = f2;
                heapClassInst.heapFloat[r1 + numDefine35] = f0;
                heapClassInst.heap32[r1 + numDefine36] = 0;
            }
            f3 = heapClassInst.heapFloat[fp + numDefineNeg50];
            f1 = f1 * f3;
            f3 = heapClassInst.heapFloat[fp + numDefineNeg51];
            f2 = f2 * f3;
            f3 = heapClassInst.heapFloat[r1 + numDefine43];
            f1 = f1 + f2;
            f2 = heapClassInst.heapFloat[fp + numDefineNeg52];
            f0 = f0 * f2;
            f0 = f1 + f0;
            f1 = -f3;
            if (!(f0 >= f1)) {
                r0 = heapClassInst.heap32[r0 + 1];
                heapClassInst.heap32[g0] = r0;
                r0 = r0 >> numDefine2;
                zn22btVoronoiSimplexSolver28updateClosestVectorAndPointsEv(i7);
                f0 = heapClassInst.heapFloat[r0 + numDefine68];
                f1 = heapClassInst.heapFloat[r0 + numDefine67];
                f2 = heapClassInst.heapFloat[r0 + numDefine66];
                heapClassInst.heap32[r1 + numDefine37] = heapClassInst.heap32[r0 + numDefine65];
                heapClassInst.heapFloat[r1 + numDefine38] = f2;
                heapClassInst.heapFloat[r1 + numDefine39] = f1;
                heapClassInst.heapFloat[r1 + numDefine40] = f0;
                r0 = 1;
                commonVariable.rg0 = r0;
                return;
            }
        }
        r0 = 0;
        commonVariable.rg0 = r0;
        return;
    }

    public static void zn22btVoronoiSimplexSolver12removeVertexEi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1];
        if (r2 > 0) {
            r3 = heapClassInst.heap32[fp + 1];
            r2 = (r2 + -1) | 0;
            r3 = r3 << numDefine4;
            r4 = (r0 + numDefine4) | 0;
            r5 = r2 << numDefine4;
            r6 = (r4 + r3) | 0;
            r4 = (r4 + r5) | 0;
            r5 = r6 >> numDefine2;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r1] = r2;
            heapClassInst.heap32[r5] = heapClassInst.heap32[r4];
            heapClassInst.heap32[r5 + 1] = heapClassInst.heap32[r4 + 1];
            heapClassInst.heap32[r5 + numDefine2] = heapClassInst.heap32[r4 + numDefine2];
            heapClassInst.heap32[r5 + numDefine3] = heapClassInst.heap32[r4 + numDefine3];
            r2 = heapClassInst.heap32[r1];
            r4 = (r0 + numDefine84) | 0;
            r2 = r2 << numDefine4;
            r5 = (r4 + r3) | 0;
            r2 = (r4 + r2) | 0;
            r4 = r5 >> numDefine2;
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[r4] = heapClassInst.heap32[r2];
            heapClassInst.heap32[r4 + 1] = heapClassInst.heap32[r2 + 1];
            heapClassInst.heap32[r4 + numDefine2] = heapClassInst.heap32[r2 + numDefine2];
            heapClassInst.heap32[r4 + numDefine3] = heapClassInst.heap32[r2 + numDefine3];
            r1 = heapClassInst.heap32[r1];
            r0 = (r0 + numDefine164) | 0;
            r1 = r1 << numDefine4;
            r2 = (r0 + r3) | 0;
            r0 = (r0 + r1) | 0;
            r1 = r2 >> numDefine2;
            r0 = r0 >> numDefine2;
            heapClassInst.heap32[r1] = heapClassInst.heap32[r0];
            heapClassInst.heap32[r1 + 1] = heapClassInst.heap32[r0 + 1];
            heapClassInst.heap32[r1 + numDefine2] = heapClassInst.heap32[r0 + numDefine2];
            heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];
            return;
        } else {
            r0 = twoEStr457;
            r1 = twoEStr1458;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine38;
            assertNew(i7);
        }
    }

    public static void zn22btVoronoiSimplexSolver22closestPtPointTriangleERK9btVector3S2S2S2R25btSubSimplexClosestResult(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine4];
        r1 = heapClassInst.heapU8[r0 + numDefine16];
        r2 = heapClassInst.heap32[fp + numDefine2];
        r3 = heapClassInst.heap32[fp + numDefine3];
        r4 = heapClassInst.heap32[fp + 1];
        r1 = r1 & numDefineNeg16;
        r5 = heapClassInst.heap32[fp];
        r2 = r2 >> numDefine2;
        heapClassInst.heap8[r0 + numDefine16] = (byte) r1;
        r3 = r3 >> numDefine2;
        r5 = r5 >> numDefine2;
        r4 = r4 >> numDefine2;
        f0 = heapClassInst.heapFloat[r2 + 1];
        f1 = heapClassInst.heapFloat[r4 + 1];
        f2 = heapClassInst.heapFloat[r3 + 1];
        f3 = heapClassInst.heapFloat[r5 + 1];
        f4 = heapClassInst.heapFloat[r2];
        f5 = heapClassInst.heapFloat[r4];
        f6 = heapClassInst.heapFloat[r3];
        f7 = heapClassInst.heapFloat[r5];
        f8 = heapClassInst.heapFloat[r2 + numDefine2];
        f9 = heapClassInst.heapFloat[r4 + numDefine2];
        f10 = heapClassInst.heapFloat[r3 + numDefine2];
        f11 = heapClassInst.heapFloat[r5 + numDefine2];
        f12 = f0 - f1;
        f13 = f4 - f5;
        f14 = f6 - f5;
        f15 = f7 - f5;
        f16 = f2 - f1;
        f17 = f3 - f1;
        f18 = f8 - f9;
        f19 = f10 - f9;
        f20 = f11 - f9;
        f21 = f13 * f15;
        f22 = f12 * f17;
        f15 = f14 * f15;
        f17 = f16 * f17;
        f21 = f21 + f22;
        f22 = f18 * f20;
        f15 = f15 + f17;
        f17 = f19 * f20;
        f20 = f21 + f22;
        f15 = f15 + f17;
        f17 = 0;
        if (!(f20 > f17)) {
            if (!(f15 > f17)) {
                r2 = r0 >> numDefine2;
                heapClassInst.heapFloat[r2] = f5;
                heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r4 + 1];
                heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r4 + numDefine2];
                r1 = r1 | 1;
                heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r4 + numDefine3];
                heapClassInst.heap8[r0 + numDefine16] = (byte) r1;
                heapClassInst.heap32[r2 + numDefine5] = numDefine53216;
                heapClassInst.heap32[r2 + numDefine6] = 0;
                heapClassInst.heap32[r2 + numDefine7] = 0;
                heapClassInst.heap32[r2 + numDefine8] = 0;
                return;
            }
        }
        f21 = f7 - f4;
        f22 = f3 - f0;
        f23 = f13 * f21;
        f24 = f12 * f22;
        f25 = f11 - f8;
        f21 = f14 * f21;
        f22 = f16 * f22;
        f23 = f23 + f24;
        f24 = f18 * f25;
        f21 = f21 + f22;
        f22 = f19 * f25;
        f23 = f23 + f24;
        f21 = f21 + f22;
        if (f23 < f17) {
            label = numDefine7;
        } else {
            if (f21 > f23) {
                label = numDefine7;
            } else {
                r3 = r0 >> numDefine2;
                heapClassInst.heapFloat[r3] = f4;
                heapClassInst.heap32[r3 + 1] = heapClassInst.heap32[r2 + 1];
                heapClassInst.heap32[r3 + numDefine2] = heapClassInst.heap32[r2 + numDefine2];
                r1 = r1 | numDefine2;
                heapClassInst.heap32[r3 + numDefine3] = heapClassInst.heap32[r2 + numDefine3];
                heapClassInst.heap8[r0 + numDefine16] = (byte) r1;
                heapClassInst.heap32[r3 + numDefine5] = 0;
                heapClassInst.heap32[r3 + numDefine6] = numDefine53216;
                label = numDefine6;
            }
        }
        repeat8: do {
            if (label == numDefine7) {
                f22 = f20 * f21;
                f24 = f23 * f15;
                f22 = f22 - f24;
                if (!(f22 > f17)) {
                    if (!(f20 < f17)) {
                        if (!(f23 > f17)) {
                            f0 = f20 - f23;
                            f0 = f20 / f0;
                            f2 = f13 * f0;
                            r3 = r0 >> numDefine2;
                            f2 = f5 + f2;
                            f3 = f12 * f0;
                            f4 = f18 * f0;
                            f1 = f1 + f3;
                            heapClassInst.heapFloat[r3] = f2;
                            f2 = f9 + f4;
                            heapClassInst.heapFloat[r3 + 1] = f1;
                            heapClassInst.heapFloat[r3 + numDefine2] = f2;
                            f1 = 1;
                            r1 = r1 | numDefine3;
                            heapClassInst.heap32[r3 + numDefine3] = 0;
                            f1 = f1 - f0;
                            heapClassInst.heap8[r0 + numDefine16] = (byte) r1;
                            heapClassInst.heapFloat[r3 + numDefine5] = f1;
                            heapClassInst.heapFloat[r3 + numDefine6] = f0;
                            break repeat8;
                        }
                    }
                }
                f7 = f7 - f6;
                f3 = f3 - f2;
                f24 = f14 * f7;
                f25 = f16 * f3;
                f11 = f11 - f10;
                f7 = f13 * f7;
                f3 = f12 * f3;
                f24 = f24 + f25;
                f25 = f19 * f11;
                f3 = f7 + f3;
                f7 = f18 * f11;
                f11 = f24 + f25;
                f3 = f3 + f7;
                if (!(f11 < f17)) {
                    if (!(f3 > f11)) {
                        r2 = r0 >> numDefine2;
                        heapClassInst.heapFloat[r2] = f6;
                        heapClassInst.heap32[r2 + 1] = heapClassInst.heap32[r3 + 1];
                        heapClassInst.heap32[r2 + numDefine2] = heapClassInst.heap32[r3 + numDefine2];
                        r1 = r1 | numDefine4;
                        heapClassInst.heap32[r2 + numDefine3] = heapClassInst.heap32[r3 + numDefine3];
                        heapClassInst.heap8[r0 + numDefine16] = (byte) r1;
                        heapClassInst.heap32[r2 + numDefine5] = 0;
                        heapClassInst.heap32[r2 + numDefine6] = 0;
                        heapClassInst.heap32[r2 + numDefine7] = numDefine53216;
                        heapClassInst.heap32[r2 + numDefine8] = 0;
                        return;
                    }
                }
                f7 = f3 * f15;
                f20 = f20 * f11;
                f7 = f7 - f20;
                if (f7 > f17) {
                    label = numDefine19;
                } else {
                    if (f15 < f17) {
                        label = numDefine19;
                    } else {
                        if (f11 > f17) {
                            label = numDefine19;
                        } else {
                            f0 = f15 - f11;
                            f0 = f15 / f0;
                            f2 = f14 * f0;
                            r2 = r0 >> numDefine2;
                            f2 = f5 + f2;
                            f3 = f16 * f0;
                            f4 = f19 * f0;
                            f1 = f1 + f3;
                            heapClassInst.heapFloat[r2] = f2;
                            f2 = f9 + f4;
                            heapClassInst.heapFloat[r2 + 1] = f1;
                            heapClassInst.heapFloat[r2 + numDefine2] = f2;
                            f1 = 1;
                            r1 = r1 | numDefine5;
                            heapClassInst.heap32[r2 + numDefine3] = 0;
                            f1 = f1 - f0;
                            heapClassInst.heap8[r0 + numDefine16] = (byte) r1;
                            heapClassInst.heapFloat[r2 + numDefine5] = f1;
                            heapClassInst.heap32[r2 + numDefine6] = 0;
                            label = numDefine18;
                        }
                    }
                }
                if (label == numDefine19) {
                    f15 = f23 * f11;
                    f20 = f3 * f21;
                    f15 = f15 - f20;
                    if (!(f15 > f17)) {
                        f20 = f21 - f23;
                        if (!(f20 < f17)) {
                            f3 = f3 - f11;
                            if (!(f3 < f17)) {
                                f1 = f20 + f3;
                                f1 = f20 / f1;
                                f5 = f6 - f4;
                                f7 = f2 - f0;
                                f5 = f5 * f1;
                                f9 = f10 - f8;
                                f7 = f7 * f1;
                                r2 = r0 >> numDefine2;
                                f5 = f4 + f5;
                                f9 = f9 * f1;
                                f7 = f0 + f7;
                                heapClassInst.heapFloat[r2] = f5;
                                f5 = f8 + f9;
                                heapClassInst.heapFloat[r2 + 1] = f7;
                                heapClassInst.heapFloat[r2 + numDefine2] = f5;
                                r1 = r1 | numDefine6;
                                heapClassInst.heap32[r2 + numDefine3] = 0;
                                f5 = 1;
                                heapClassInst.heap8[r0 + numDefine16] = (byte) r1;
                                f5 = f5 - f1;
                                heapClassInst.heap32[r2 + numDefine5] = 0;
                                heapClassInst.heapFloat[r2 + numDefine6] = f5;
                                heapClassInst.heapFloat[r2 + numDefine7] = f1;
                                heapClassInst.heap32[r2 + numDefine8] = 0;
                                return;
                            }
                        }
                    }
                    f0 = f15 + f7;
                    f0 = f0 + f22;
                    f2 = 1;
                    f0 = f2 / f0;
                    f3 = f7 * f0;
                    f0 = f22 * f0;
                    f4 = f13 * f3;
                    f6 = f12 * f3;
                    f4 = f5 + f4;
                    f5 = f14 * f0;
                    r2 = r0 >> numDefine2;
                    f4 = f4 + f5;
                    f5 = f18 * f3;
                    f1 = f1 + f6;
                    f6 = f16 * f0;
                    f5 = f9 + f5;
                    f7 = f19 * f0;
                    f1 = f1 + f6;
                    heapClassInst.heapFloat[r2] = f4;
                    f4 = f5 + f7;
                    heapClassInst.heapFloat[r2 + 1] = f1;
                    heapClassInst.heapFloat[r2 + numDefine2] = f4;
                    f1 = f2 - f3;
                    r1 = r1 | numDefine7;
                    heapClassInst.heap32[r2 + numDefine3] = 0;
                    f1 = f1 - f0;
                    heapClassInst.heap8[r0 + numDefine16] = (byte) r1;
                    heapClassInst.heapFloat[r2 + numDefine5] = f1;
                    heapClassInst.heapFloat[r2 + numDefine6] = f3;
                }
                heapClassInst.heapFloat[r2 + numDefine7] = f0;
                heapClassInst.heap32[r2 + numDefine8] = 0;
                return;
            }
        } while (false);
        heapClassInst.heap32[r3 + numDefine7] = 0;
        heapClassInst.heap32[r3 + numDefine8] = 0;
        return;
    }

    public static void zn22btVoronoiSimplexSolver19pointOutsideOfPlaneERK9btVector3S2S2S2S2(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        f0 = heapClassInst.heapFloat[fp + numDefine5];
        f1 = heapClassInst.heapFloat[fp + numDefine8];
        f2 = heapClassInst.heapFloat[fp + numDefine11];
        f3 = heapClassInst.heapFloat[fp + numDefine4];
        f4 = heapClassInst.heapFloat[fp + numDefine10];
        f5 = heapClassInst.heapFloat[fp + numDefine7];
        f6 = heapClassInst.heapFloat[fp + numDefine3];
        f7 = heapClassInst.heapFloat[fp + numDefine6];
        f8 = heapClassInst.heapFloat[fp + numDefine9];
        f1 = f1 - f0;
        f4 = f4 - f3;
        f7 = f7 - f6;
        f2 = f2 - f0;
        f5 = f5 - f3;
        f8 = f8 - f6;
        f9 = heapClassInst.heapFloat[fp + numDefine12];
        f10 = heapClassInst.heapFloat[fp + numDefine13];
        f11 = f5 * f2;
        f12 = f1 * f4;
        f1 = f1 * f8;
        f2 = f7 * f2;
        f11 = f11 - f12;
        f9 = f9 - f6;
        f1 = f1 - f2;
        f2 = f10 - f3;
        f10 = heapClassInst.heapFloat[fp + numDefine14];
        f4 = f7 * f4;
        f5 = f5 * f8;
        f4 = f4 - f5;
        f5 = f10 - f0;
        f7 = f9 * f11;
        f2 = f2 * f1;
        f2 = f7 + f2;
        f5 = f5 * f4;
        f2 = f2 + f5;
        f5 = f2 * f2;
        f7 = (float) numDefineFloat9069;
        if (f5 < f7) {
            r0 = -1;
            commonVariable.rg0 = r0;
            return;
        } else {
            f5 = heapClassInst.heapFloat[fp];
            f7 = heapClassInst.heapFloat[fp + 1];
            f8 = heapClassInst.heapFloat[fp + numDefine2];
            f5 = f5 - f6;
            f3 = f7 - f3;
            f5 = f5 * f11;
            f1 = f3 * f1;
            f0 = f8 - f0;
            f1 = f5 + f1;
            f0 = f0 * f4;
            f0 = f1 + f0;
            f0 = f0 * f2;
            f1 = 0;

            r0 = f0 < f1 ? 1 : 0;
            r0 = r0 & 1;
            commonVariable.rg0 = r0;
            return;
        }
    }

    public static void zn22btVoronoiSimplexSolver14reduceVerticesERK15btUsageBitfield(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1];
        r3 = heapClassInst.heap32[fp + 1];
        if (r2 > numDefine3) {
            r2 = heapClassInst.heapU8[r3];
            r4 = r2 & numDefine8;
            if (r4 == 0) {
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = numDefine3;
                zn22btVoronoiSimplexSolver12removeVertexEi(i7);
                r2 = heapClassInst.heap32[r1];
                label = numDefine3;
            } else {
                label = numDefine5;
            }
        } else {
            label = numDefine3;
        }
        if (label == numDefine3) {
            if (r2 > numDefine2) {
                r2 = heapClassInst.heapU8[r3];
                label = numDefine5;
            } else {
                label = numDefine7;
            }
        }
        if (label == numDefine5) {
            r4 = r2 & numDefine4;
            if (r4 == 0) {
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = numDefine2;
                zn22btVoronoiSimplexSolver12removeVertexEi(i7);
                r2 = heapClassInst.heap32[r1];
                label = numDefine7;
            } else {
                label = numDefine9;
            }
        }
        if (label == numDefine7) {
            if (r2 > 1) {
                r2 = heapClassInst.heapU8[r3];
                label = numDefine9;
            } else {
                label = numDefine11;
            }
        }
        if (label == numDefine9) {
            r4 = r2 & numDefine2;
            if (r4 == 0) {
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = 1;
                zn22btVoronoiSimplexSolver12removeVertexEi(i7);
                r2 = heapClassInst.heap32[r1];
                label = numDefine11;
            } else {
                label = numDefine13;
            }
        }
        if (label == numDefine11) {
            if (r2 < 1) {
                label = numDefine14;
            } else {
                r2 = heapClassInst.heapU8[r3];
                label = numDefine13;
            }
        }
        if (label == numDefine13) {
            r1 = r2 & 1;
            if (r1 == 0) {
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = 0;
                zn22btVoronoiSimplexSolver12removeVertexEi(i7);
                return;
            }
        }
        return;
    }

    public static void zn22btVoronoiSimplexSolver28updateClosestVectorAndPointsEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg136;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heapU8[r0 + numDefine356];
        if (r1 != 0) {
            r1 = 0;
            r2 = r0 >> numDefine2;
            heapClassInst.heap8[r0 + numDefine352] = (byte) r1;
            heapClassInst.heap32[r2 + numDefine84] = 0;
            heapClassInst.heap32[r2 + numDefine85] = 0;
            heapClassInst.heap32[r2 + numDefine86] = 0;
            heapClassInst.heap32[r2 + numDefine87] = 0;
            r3 = heapClassInst.heapU8[r0 + numDefine332];
            r4 = r3 & numDefineNeg16;
            heapClassInst.heap8[r0 + numDefine332] = (byte) r4;
            heapClassInst.heap8[r0 + numDefine356] = (byte) r1;
            r5 = heapClassInst.heap32[r2];
            repeat3: do {
                if (r5 > 1) {
                    repeat5: do {
                        if (r5 == numDefine2) {
                            f0 = 0;
                            f1 = heapClassInst.heapFloat[r2 + numDefine2];
                            f2 = heapClassInst.heapFloat[r2 + numDefine6];
                            f3 = heapClassInst.heapFloat[r2 + 1];
                            f4 = heapClassInst.heapFloat[r2 + numDefine5];
                            f5 = heapClassInst.heapFloat[r2 + numDefine3];
                            f6 = heapClassInst.heapFloat[r2 + numDefine7];
                            f2 = f2 - f1;
                            f1 = f0 - f1;
                            f4 = f4 - f3;
                            f3 = f0 - f3;
                            f6 = f6 - f5;
                            f5 = f0 - f5;
                            f3 = f4 * f3;
                            f1 = f2 * f1;
                            f1 = f3 + f1;
                            f3 = f6 * f5;
                            f1 = f1 + f3;
                            if (f1 <= f0) {
                                r1 = r4 | 1;
                                heapClassInst.heap8[r0 + numDefine332] = (byte) r1;
                                f1 = f0;
                            } else {
                                f3 = f4 * f4;
                                f2 = f2 * f2;
                                f2 = f3 + f2;
                                f3 = f6 * f6;
                                f2 = f2 + f3;
                                if (f1 >= f2) {
                                    f1 = 1;
                                    r1 = r4 | numDefine2;
                                    heapClassInst.heap8[r0 + numDefine332] = (byte) r1;
                                } else {
                                    f1 = f1 / f2;
                                    r1 = r4 | numDefine3;
                                    heapClassInst.heap8[r0 + numDefine332] = (byte) r1;
                                }
                            }
                            f2 = 1;
                            f2 = f2 - f1;
                            heapClassInst.heapFloat[r2 + numDefine84] = f2;
                            heapClassInst.heapFloat[r2 + numDefine85] = f1;
                            heapClassInst.heap32[r2 + numDefine86] = 0;
                            heapClassInst.heap32[r2 + numDefine87] = 0;
                            f2 = heapClassInst.heapFloat[r2 + numDefine25];
                            f3 = heapClassInst.heapFloat[r2 + numDefine21];
                            f2 = f2 - f3;
                            f4 = heapClassInst.heapFloat[r2 + numDefine26];
                            f5 = heapClassInst.heapFloat[r2 + numDefine22];
                            f4 = f4 - f5;
                            f2 = f2 * f1;
                            f6 = heapClassInst.heapFloat[r2 + numDefine27];
                            f7 = heapClassInst.heapFloat[r2 + numDefine23];
                            f6 = f6 - f7;
                            f4 = f4 * f1;
                            f2 = f3 + f2;
                            f3 = f6 * f1;
                            f4 = f5 + f4;
                            heapClassInst.heapFloat[r2 + numDefine61] = f2;
                            f3 = f7 + f3;
                            heapClassInst.heapFloat[r2 + numDefine62] = f4;
                            heapClassInst.heapFloat[r2 + numDefine63] = f3;
                            heapClassInst.heap32[r2 + numDefine64] = 0;
                            f5 = heapClassInst.heapFloat[r2 + numDefine45];
                            f6 = heapClassInst.heapFloat[r2 + numDefine41];
                            f5 = f5 - f6;
                            f7 = heapClassInst.heapFloat[r2 + numDefine46];
                            f8 = heapClassInst.heapFloat[r2 + numDefine42];
                            f7 = f7 - f8;
                            f5 = f5 * f1;
                            f9 = heapClassInst.heapFloat[r2 + numDefine47];
                            f10 = heapClassInst.heapFloat[r2 + numDefine43];
                            f9 = f9 - f10;
                            f7 = f7 * f1;
                            f5 = f6 + f5;
                            f1 = f9 * f1;
                            f6 = f8 + f7;
                            heapClassInst.heapFloat[r2 + numDefine65] = f5;
                            f1 = f10 + f1;
                            heapClassInst.heapFloat[r2 + numDefine66] = f6;
                            heapClassInst.heapFloat[r2 + numDefine67] = f1;
                            f2 = f2 - f5;
                            heapClassInst.heap32[r2 + numDefine68] = 0;
                            f4 = f4 - f6;
                            heapClassInst.heapFloat[r2 + numDefine69] = f2;
                            f1 = f3 - f1;
                            heapClassInst.heapFloat[r2 + numDefine70] = f4;
                            heapClassInst.heapFloat[r2 + numDefine71] = f1;
                            heapClassInst.heap32[r2 + numDefine72] = 0;
                            r1 = (r0 + numDefine332) | 0;
                            heapClassInst.heap32[g0] = r0;
                            heapClassInst.heap32[g0 + 1] = r1;
                            zn22btVoronoiSimplexSolver14reduceVerticesERK15btUsageBitfield(i7);
                            f1 = heapClassInst.heapFloat[r2 + numDefine84];
                            if (f1 >= f0) {
                                f0 = heapClassInst.heapFloat[r2 + numDefine85];
                                f1 = 0;
                                if (!(f0 < f1)) {
                                    f0 = heapClassInst.heapFloat[r2 + numDefine86];
                                    if (!(f0 < f1)) {
                                        f0 = heapClassInst.heapFloat[r2 + numDefine87];

                                        r1 = f0 >= f1 ? 1 : 0;
                                        r1 = r1 & 1;
                                        break repeat5;
                                    }
                                }
                            }
                            r1 = 0;
                        } else {
                            if (r5 == numDefine3) {
                                r1 = sp + numDefineNeg56;
                                r3 = r1 >> numDefine2;
                                heapClassInst.heap32[fp + numDefineNeg14] = 0;
                                heapClassInst.heap32[r3 + 1] = 0;
                                heapClassInst.heap32[r3 + numDefine2] = 0;
                                heapClassInst.heap32[r3 + numDefine3] = 0;
                                r3 = (r0 + numDefine4) | 0;
                                r4 = (r0 + numDefine20) | 0;
                                r5 = (r0 + numDefine36) | 0;
                                r6 = (r0 + numDefine316) | 0;
                                heapClassInst.heap32[g0] = r1;
                                heapClassInst.heap32[g0 + 1] = r3;
                                heapClassInst.heap32[g0 + numDefine2] = r4;
                                heapClassInst.heap32[g0 + numDefine3] = r5;
                                heapClassInst.heap32[g0 + numDefine4] = r6;
                                zn22btVoronoiSimplexSolver22closestPtPointTriangleERK9btVector3S2S2S2R25btSubSimplexClosestResult(i7);
                                f0 = heapClassInst.heapFloat[r2 + numDefine85];
                                f1 = heapClassInst.heapFloat[r2 + numDefine25];
                                f2 = heapClassInst.heapFloat[r2 + numDefine84];
                                f3 = heapClassInst.heapFloat[r2 + numDefine21];
                                f4 = heapClassInst.heapFloat[r2 + numDefine26];
                                f5 = heapClassInst.heapFloat[r2 + numDefine22];
                                f3 = f3 * f2;
                                f1 = f1 * f0;
                                f6 = heapClassInst.heapFloat[r2 + numDefine86];
                                f7 = heapClassInst.heapFloat[r2 + numDefine29];
                                f8 = heapClassInst.heapFloat[r2 + numDefine31];
                                f9 = heapClassInst.heapFloat[r2 + numDefine30];
                                f10 = heapClassInst.heapFloat[r2 + numDefine27];
                                f11 = heapClassInst.heapFloat[r2 + numDefine23];
                                f5 = f5 * f2;
                                f4 = f4 * f0;
                                f1 = f3 + f1;
                                f3 = f7 * f6;
                                f7 = f11 * f2;
                                f10 = f10 * f0;
                                f4 = f5 + f4;
                                f5 = f9 * f6;
                                f1 = f1 + f3;
                                f3 = f7 + f10;
                                f7 = f8 * f6;
                                f4 = f4 + f5;
                                heapClassInst.heapFloat[r2 + numDefine61] = f1;
                                f3 = f3 + f7;
                                heapClassInst.heapFloat[r2 + numDefine62] = f4;
                                heapClassInst.heapFloat[r2 + numDefine63] = f3;
                                heapClassInst.heap32[r2 + numDefine64] = 0;
                                f5 = heapClassInst.heapFloat[r2 + numDefine45];
                                f7 = heapClassInst.heapFloat[r2 + numDefine41];
                                f8 = heapClassInst.heapFloat[r2 + numDefine49];
                                f9 = heapClassInst.heapFloat[r2 + numDefine46];
                                f10 = heapClassInst.heapFloat[r2 + numDefine42];
                                f7 = f7 * f2;
                                f5 = f5 * f0;
                                f11 = heapClassInst.heapFloat[r2 + numDefine51];
                                f12 = heapClassInst.heapFloat[r2 + numDefine50];
                                f13 = heapClassInst.heapFloat[r2 + numDefine47];
                                f14 = heapClassInst.heapFloat[r2 + numDefine43];
                                f10 = f10 * f2;
                                f9 = f9 * f0;
                                f5 = f7 + f5;
                                f7 = f8 * f6;
                                f5 = f5 + f7;
                                f2 = f14 * f2;
                                f0 = f13 * f0;
                                f7 = f10 + f9;
                                f8 = f12 * f6;
                                f7 = f7 + f8;
                                heapClassInst.heapFloat[r2 + numDefine65] = f5;
                                f0 = f2 + f0;
                                f2 = f11 * f6;
                                f0 = f0 + f2;
                                heapClassInst.heapFloat[r2 + numDefine66] = f7;
                                heapClassInst.heapFloat[r2 + numDefine67] = f0;
                                f1 = f1 - f5;
                                heapClassInst.heap32[r2 + numDefine68] = 0;
                                f2 = f4 - f7;
                                heapClassInst.heapFloat[r2 + numDefine69] = f1;
                                f0 = f3 - f0;
                                heapClassInst.heapFloat[r2 + numDefine70] = f2;
                                heapClassInst.heapFloat[r2 + numDefine71] = f0;
                                heapClassInst.heap32[r2 + numDefine72] = 0;
                                r1 = (r0 + numDefine332) | 0;
                                heapClassInst.heap32[g0] = r0;
                                heapClassInst.heap32[g0 + 1] = r1;
                                zn22btVoronoiSimplexSolver14reduceVerticesERK15btUsageBitfield(i7);
                                f0 = heapClassInst.heapFloat[r2 + numDefine84];
                                f1 = 0;
                                if (f0 >= f1) {
                                    f0 = heapClassInst.heapFloat[r2 + numDefine85];
                                    if (!(f0 < f1)) {
                                        f0 = heapClassInst.heapFloat[r2 + numDefine86];
                                        if (!(f0 < f1)) {
                                            f0 = heapClassInst.heapFloat[r2 + numDefine87];

                                            r1 = f0 >= f1 ? 1 : 0;
                                            r1 = r1 & 1;
                                            break repeat5;
                                        }
                                    }
                                }
                                r1 = 0;
                            } else {
                                if (r5 == numDefine4) {
                                    r4 = sp + numDefineNeg72;
                                    r5 = r4 >> numDefine2;
                                    heapClassInst.heap32[fp + numDefineNeg18] = 0;
                                    heapClassInst.heap32[r5 + 1] = 0;
                                    heapClassInst.heap32[r5 + numDefine2] = 0;
                                    heapClassInst.heap32[r5 + numDefine3] = 0;
                                    heapClassInst.heap8[sp + numDefineNeg24] = (byte) r1;
                                    heapClassInst.heap32[r2 + numDefine79] = 0;
                                    heapClassInst.heap32[r2 + numDefine80] = 0;
                                    heapClassInst.heap32[r2 + numDefine81] = 0;
                                    r3 = r3 | numDefine15;
                                    heapClassInst.heap32[r2 + numDefine82] = 0;
                                    heapClassInst.heap8[r0 + numDefine332] = (byte) r3;
                                    f0 = heapClassInst.heapFloat[r2 + numDefine11];
                                    f1 = heapClassInst.heapFloat[r2 + numDefine7];
                                    f2 = heapClassInst.heapFloat[r2 + numDefine15];
                                    f3 = heapClassInst.heapFloat[r2 + 1];
                                    f4 = heapClassInst.heapFloat[r2 + numDefine2];
                                    f5 = heapClassInst.heapFloat[r2 + numDefine3];
                                    f6 = heapClassInst.heapFloat[r2 + numDefine5];
                                    f7 = heapClassInst.heapFloat[r2 + numDefine6];
                                    f8 = heapClassInst.heapFloat[r2 + numDefine9];
                                    f9 = heapClassInst.heapFloat[r2 + numDefine10];
                                    f10 = heapClassInst.heapFloat[r2 + numDefine13];
                                    f11 = heapClassInst.heapFloat[r2 + numDefine14];
                                    heapClassInst.heap32[g0] = 0;
                                    heapClassInst.heap32[g0 + 1] = 0;
                                    heapClassInst.heap32[g0 + numDefine2] = 0;
                                    heapClassInst.heapFloat[g0 + numDefine3] = f3;
                                    heapClassInst.heapFloat[g0 + numDefine4] = f4;
                                    heapClassInst.heapFloat[g0 + numDefine5] = f5;
                                    heapClassInst.heapFloat[g0 + numDefine6] = f6;
                                    heapClassInst.heapFloat[g0 + numDefine7] = f7;
                                    heapClassInst.heapFloat[g0 + numDefine8] = f1;
                                    heapClassInst.heapFloat[g0 + numDefine9] = f8;
                                    heapClassInst.heapFloat[g0 + numDefine10] = f9;
                                    heapClassInst.heapFloat[g0 + numDefine11] = f0;
                                    heapClassInst.heapFloat[g0 + numDefine12] = f10;
                                    heapClassInst.heapFloat[g0 + numDefine13] = f11;
                                    heapClassInst.heapFloat[g0 + numDefine14] = f2;
                                    zn22btVoronoiSimplexSolver19pointOutsideOfPlaneERK9btVector3S2S2S2S2(i7);
                                    r3 = commonVariable.rg0;
                                    heapClassInst.heap32[g0] = 0;
                                    heapClassInst.heap32[g0 + 1] = 0;
                                    heapClassInst.heap32[g0 + numDefine2] = 0;
                                    heapClassInst.heapFloat[g0 + numDefine3] = f3;
                                    heapClassInst.heapFloat[g0 + numDefine4] = f4;
                                    heapClassInst.heapFloat[g0 + numDefine5] = f5;
                                    heapClassInst.heapFloat[g0 + numDefine6] = f8;
                                    heapClassInst.heapFloat[g0 + numDefine7] = f9;
                                    heapClassInst.heapFloat[g0 + numDefine8] = f0;
                                    heapClassInst.heapFloat[g0 + numDefine9] = f10;
                                    heapClassInst.heapFloat[g0 + numDefine10] = f11;
                                    heapClassInst.heapFloat[g0 + numDefine11] = f2;
                                    heapClassInst.heapFloat[g0 + numDefine12] = f6;
                                    heapClassInst.heapFloat[g0 + numDefine13] = f7;
                                    heapClassInst.heapFloat[g0 + numDefine14] = f1;
                                    zn22btVoronoiSimplexSolver19pointOutsideOfPlaneERK9btVector3S2S2S2S2(i7);
                                    r6 = commonVariable.rg0;
                                    heapClassInst.heap32[g0] = 0;
                                    heapClassInst.heap32[g0 + 1] = 0;
                                    heapClassInst.heap32[g0 + numDefine2] = 0;
                                    heapClassInst.heapFloat[g0 + numDefine3] = f3;
                                    heapClassInst.heapFloat[g0 + numDefine4] = f4;
                                    heapClassInst.heapFloat[g0 + numDefine5] = f5;
                                    heapClassInst.heapFloat[g0 + numDefine6] = f10;
                                    heapClassInst.heapFloat[g0 + numDefine7] = f11;
                                    heapClassInst.heapFloat[g0 + numDefine8] = f2;
                                    heapClassInst.heapFloat[g0 + numDefine9] = f6;
                                    heapClassInst.heapFloat[g0 + numDefine10] = f7;
                                    heapClassInst.heapFloat[g0 + numDefine11] = f1;
                                    heapClassInst.heapFloat[g0 + numDefine12] = f8;
                                    heapClassInst.heapFloat[g0 + numDefine13] = f9;
                                    heapClassInst.heapFloat[g0 + numDefine14] = f0;
                                    zn22btVoronoiSimplexSolver19pointOutsideOfPlaneERK9btVector3S2S2S2S2(i7);
                                    r7 = commonVariable.rg0;
                                    heapClassInst.heap32[g0] = 0;
                                    heapClassInst.heap32[g0 + 1] = 0;
                                    heapClassInst.heap32[g0 + numDefine2] = 0;
                                    heapClassInst.heapFloat[g0 + numDefine3] = f6;
                                    heapClassInst.heapFloat[g0 + numDefine4] = f7;
                                    heapClassInst.heapFloat[g0 + numDefine5] = f1;
                                    heapClassInst.heapFloat[g0 + numDefine6] = f10;
                                    heapClassInst.heapFloat[g0 + numDefine7] = f11;
                                    heapClassInst.heapFloat[g0 + numDefine8] = f2;
                                    heapClassInst.heapFloat[g0 + numDefine9] = f8;
                                    heapClassInst.heapFloat[g0 + numDefine10] = f9;
                                    heapClassInst.heapFloat[g0 + numDefine11] = f0;
                                    heapClassInst.heapFloat[g0 + numDefine12] = f3;
                                    heapClassInst.heapFloat[g0 + numDefine13] = f4;
                                    heapClassInst.heapFloat[g0 + numDefine14] = f5;
                                    r8 = r6 | r3;
                                    zn22btVoronoiSimplexSolver19pointOutsideOfPlaneERK9btVector3S2S2S2S2(i7);
                                    r9 = commonVariable.rg0;
                                    if (!(r8 < 0)) {
                                        r10 = r9 | r7;
                                        if (!(r10 < 0)) {
                                            r8 = r8 | r7;
                                            r8 = r8 | r9;
                                            if (r8 == 0) {
                                                r1 = 1;
                                                heapClassInst.heap8[r0 + numDefine312] = (byte) r1;
                                                heapClassInst.heap32[r2 + numDefine69] = 0;
                                                heapClassInst.heap32[r2 + numDefine70] = 0;
                                                heapClassInst.heap32[r2 + numDefine71] = 0;
                                                heapClassInst.heap32[r2 + numDefine72] = 0;
                                                commonVariable.rg0 = r1;
                                                return;
                                            } else {
                                                r8 = (r0 + numDefine4) | 0;
                                                r10 = (r0 + numDefine20) | 0;
                                                r11 = (r0 + numDefine36) | 0;
                                                r12 = (r0 + numDefine52) | 0;
                                                if (r3 != 0) {
                                                    r3 = sp + numDefineNeg40;
                                                    heapClassInst.heap32[g0] = r4;
                                                    heapClassInst.heap32[g0 + 1] = r8;
                                                    heapClassInst.heap32[g0 + numDefine2] = r10;
                                                    heapClassInst.heap32[g0 + numDefine3] = r11;
                                                    heapClassInst.heap32[g0 + numDefine4] = r3;
                                                    zn22btVoronoiSimplexSolver22closestPtPointTriangleERK9btVector3S2S2S2R25btSubSimplexClosestResult(i7);
                                                    r3 = r3 >> numDefine2;
                                                    f1 = heapClassInst.heapFloat[fp + numDefineNeg10];
                                                    f0 = heapClassInst.heapFloat[fp + numDefineNeg18];
                                                    f2 = heapClassInst.heapFloat[r3 + 1];
                                                    f3 = heapClassInst.heapFloat[r5 + 1];
                                                    f0 = f1 - f0;
                                                    f3 = f2 - f3;
                                                    f4 = heapClassInst.heapFloat[r3 + numDefine2];
                                                    f5 = heapClassInst.heapFloat[r5 + numDefine2];
                                                    f5 = f4 - f5;
                                                    f0 = f0 * f0;
                                                    f3 = f3 * f3;
                                                    f0 = f0 + f3;
                                                    f3 = f5 * f5;
                                                    f0 = f0 + f3;
                                                    f3 = (float) numDefineFloat4868;
                                                    if (f0 >= f3) {
                                                        label = numDefine31;
                                                    } else {
                                                        f3 = heapClassInst.heapFloat[r3 + numDefine3];
                                                        heapClassInst.heapFloat[r2 + numDefine79] = f1;
                                                        heapClassInst.heapFloat[r2 + numDefine80] = f2;
                                                        heapClassInst.heapFloat[r2 + numDefine81] = f4;
                                                        heapClassInst.heapFloat[r2 + numDefine82] = f3;
                                                        r13 = heapClassInst.heapU8[sp + numDefineNeg24];
                                                        r14 = heapClassInst.heapU8[r0 + numDefine332];
                                                        r15 = r13 & 1;
                                                        r14 = r14 & numDefine240;
                                                        r14 = r15 | r14;
                                                        r15 = r13 & numDefine2;
                                                        r14 = r14 | r15;
                                                        r13 = r13 & numDefine4;
                                                        r13 = r14 | r13;
                                                        heapClassInst.heap8[r0 + numDefine332] = (byte) r13;
                                                        f1 = heapClassInst.heapFloat[r3 + numDefine7];
                                                        f2 = heapClassInst.heapFloat[r3 + numDefine6];
                                                        heapClassInst.heap32[r2 + numDefine84] = heapClassInst.heap32[r3 + numDefine5];
                                                        heapClassInst.heapFloat[r2 + numDefine85] = f2;
                                                        heapClassInst.heapFloat[r2 + numDefine86] = f1;
                                                        heapClassInst.heap32[r2 + numDefine87] = 0;
                                                        label = numDefine34;
                                                    }
                                                } else {
                                                    label = numDefine31;
                                                }
                                                if (label == numDefine31) {
                                                    f0 = (float) numDefineFloat4868;
                                                }
                                                if (r6 != 0) {
                                                    r3 = sp + numDefineNeg40;
                                                    heapClassInst.heap32[g0] = r4;
                                                    heapClassInst.heap32[g0 + 1] = r8;
                                                    heapClassInst.heap32[g0 + numDefine2] = r11;
                                                    heapClassInst.heap32[g0 + numDefine3] = r12;
                                                    heapClassInst.heap32[g0 + numDefine4] = r3;
                                                    zn22btVoronoiSimplexSolver22closestPtPointTriangleERK9btVector3S2S2S2R25btSubSimplexClosestResult(i7);
                                                    r3 = r3 >> numDefine2;
                                                    f1 = heapClassInst.heapFloat[fp + numDefineNeg10];
                                                    f2 = heapClassInst.heapFloat[fp + numDefineNeg18];
                                                    f3 = heapClassInst.heapFloat[r3 + 1];
                                                    f4 = heapClassInst.heapFloat[r5 + 1];
                                                    f2 = f1 - f2;
                                                    f4 = f3 - f4;
                                                    f5 = heapClassInst.heapFloat[r3 + numDefine2];
                                                    f6 = heapClassInst.heapFloat[r5 + numDefine2];
                                                    f6 = f5 - f6;
                                                    f2 = f2 * f2;
                                                    f4 = f4 * f4;
                                                    f2 = f2 + f4;
                                                    f4 = f6 * f6;
                                                    f2 = f2 + f4;
                                                    if (!(f2 >= f0)) {
                                                        f0 = heapClassInst.heapFloat[r3 + numDefine3];
                                                        heapClassInst.heapFloat[r2 + numDefine79] = f1;
                                                        heapClassInst.heapFloat[r2 + numDefine80] = f3;
                                                        heapClassInst.heapFloat[r2 + numDefine81] = f5;
                                                        heapClassInst.heapFloat[r2 + numDefine82] = f0;
                                                        r6 = heapClassInst.heapU8[sp + numDefineNeg24];
                                                        r13 = heapClassInst.heapU8[r0 + numDefine332];
                                                        r14 = r6 << 1;
                                                        r6 = r6 & 1;
                                                        r13 = r13 & numDefine240;
                                                        r6 = r6 | r13;
                                                        r13 = r14 & numDefine4;
                                                        r6 = r6 | r13;
                                                        r13 = r14 & numDefine8;
                                                        r6 = r6 | r13;
                                                        heapClassInst.heap8[r0 + numDefine332] = (byte) r6;
                                                        f0 = heapClassInst.heapFloat[r3 + numDefine7];
                                                        f1 = heapClassInst.heapFloat[r3 + numDefine6];
                                                        heapClassInst.heap32[r2 + numDefine84] = heapClassInst.heap32[r3 + numDefine5];
                                                        heapClassInst.heap32[r2 + numDefine85] = 0;
                                                        heapClassInst.heapFloat[r2 + numDefine86] = f1;
                                                        heapClassInst.heapFloat[r2 + numDefine87] = f0;
                                                        f0 = f2;
                                                    }
                                                }
                                                if (r7 != 0) {
                                                    r3 = sp + numDefineNeg40;
                                                    heapClassInst.heap32[g0] = r4;
                                                    heapClassInst.heap32[g0 + 1] = r8;
                                                    heapClassInst.heap32[g0 + numDefine2] = r12;
                                                    heapClassInst.heap32[g0 + numDefine3] = r10;
                                                    heapClassInst.heap32[g0 + numDefine4] = r3;
                                                    zn22btVoronoiSimplexSolver22closestPtPointTriangleERK9btVector3S2S2S2R25btSubSimplexClosestResult(i7);
                                                    r3 = r3 >> numDefine2;
                                                    f1 = heapClassInst.heapFloat[fp + numDefineNeg10];
                                                    f2 = heapClassInst.heapFloat[fp + numDefineNeg18];
                                                    f3 = heapClassInst.heapFloat[r3 + 1];
                                                    f4 = heapClassInst.heapFloat[r5 + 1];
                                                    f2 = f1 - f2;
                                                    f4 = f3 - f4;
                                                    f5 = heapClassInst.heapFloat[r3 + numDefine2];
                                                    f6 = heapClassInst.heapFloat[r5 + numDefine2];
                                                    f6 = f5 - f6;
                                                    f2 = f2 * f2;
                                                    f4 = f4 * f4;
                                                    f2 = f2 + f4;
                                                    f4 = f6 * f6;
                                                    f2 = f2 + f4;
                                                    if (!(f2 >= f0)) {
                                                        f0 = heapClassInst.heapFloat[r3 + numDefine3];
                                                        heapClassInst.heapFloat[r2 + numDefine79] = f1;
                                                        heapClassInst.heapFloat[r2 + numDefine80] = f3;
                                                        heapClassInst.heapFloat[r2 + numDefine81] = f5;
                                                        heapClassInst.heapFloat[r2 + numDefine82] = f0;
                                                        r6 = heapClassInst.heapU8[sp + numDefineNeg24];
                                                        r7 = heapClassInst.heapU8[r0 + numDefine332];
                                                        r8 = r6 >>> 1;
                                                        r13 = r6 & 1;
                                                        r7 = r7 & numDefine240;
                                                        r6 = r6 << numDefine2;
                                                        r7 = r13 | r7;
                                                        r8 = r8 & numDefine2;
                                                        r7 = r7 | r8;
                                                        r6 = r6 & numDefine8;
                                                        r6 = r7 | r6;
                                                        heapClassInst.heap8[r0 + numDefine332] = (byte) r6;
                                                        f0 = heapClassInst.heapFloat[r3 + numDefine6];
                                                        f1 = heapClassInst.heapFloat[r3 + numDefine7];
                                                        heapClassInst.heap32[r2 + numDefine84] = heapClassInst.heap32[r3 + numDefine5];
                                                        heapClassInst.heapFloat[r2 + numDefine85] = f1;
                                                        heapClassInst.heap32[r2 + numDefine86] = 0;
                                                        heapClassInst.heapFloat[r2 + numDefine87] = f0;
                                                        f0 = f2;
                                                    }
                                                }
                                                if (!(r9 == 0)) {
                                                    r3 = sp + numDefineNeg40;
                                                    heapClassInst.heap32[g0] = r4;
                                                    heapClassInst.heap32[g0 + 1] = r10;
                                                    heapClassInst.heap32[g0 + numDefine2] = r12;
                                                    heapClassInst.heap32[g0 + numDefine3] = r11;
                                                    heapClassInst.heap32[g0 + numDefine4] = r3;
                                                    zn22btVoronoiSimplexSolver22closestPtPointTriangleERK9btVector3S2S2S2R25btSubSimplexClosestResult(i7);
                                                    r3 = r3 >> numDefine2;
                                                    f1 = heapClassInst.heapFloat[fp + numDefineNeg10];
                                                    f2 = heapClassInst.heapFloat[fp + numDefineNeg18];
                                                    f3 = heapClassInst.heapFloat[r3 + 1];
                                                    f4 = heapClassInst.heapFloat[r5 + 1];
                                                    f2 = f1 - f2;
                                                    f4 = f3 - f4;
                                                    f5 = heapClassInst.heapFloat[r3 + numDefine2];
                                                    f6 = heapClassInst.heapFloat[r5 + numDefine2];
                                                    f6 = f5 - f6;
                                                    f2 = f2 * f2;
                                                    f4 = f4 * f4;
                                                    f2 = f2 + f4;
                                                    f4 = f6 * f6;
                                                    f2 = f2 + f4;
                                                    if (!(f2 >= f0)) {
                                                        f0 = heapClassInst.heapFloat[r3 + numDefine3];
                                                        heapClassInst.heapFloat[r2 + numDefine79] = f1;
                                                        heapClassInst.heapFloat[r2 + numDefine80] = f3;
                                                        heapClassInst.heapFloat[r2 + numDefine81] = f5;
                                                        heapClassInst.heapFloat[r2 + numDefine82] = f0;
                                                        r4 = heapClassInst.heapU8[sp + numDefineNeg24];
                                                        r5 = heapClassInst.heapU8[r0 + numDefine332];
                                                        r6 = r4 << 1;
                                                        r6 = r6 & numDefine2;
                                                        r5 = r5 & numDefine240;
                                                        r7 = r4 << numDefine2;
                                                        r5 = r6 | r5;
                                                        r4 = r4 & numDefine4;
                                                        r4 = r5 | r4;
                                                        r5 = r7 & numDefine8;
                                                        r4 = r4 | r5;
                                                        heapClassInst.heap8[r0 + numDefine332] = (byte) r4;
                                                        f0 = heapClassInst.heapFloat[r3 + numDefine6];
                                                        f1 = heapClassInst.heapFloat[r3 + numDefine7];
                                                        f2 = heapClassInst.heapFloat[r3 + numDefine5];
                                                        heapClassInst.heap32[r2 + numDefine84] = 0;
                                                        heapClassInst.heapFloat[r2 + numDefine85] = f2;
                                                        heapClassInst.heapFloat[r2 + numDefine86] = f1;
                                                        heapClassInst.heapFloat[r2 + numDefine87] = f0;
                                                    }
                                                }
                                                f0 = heapClassInst.heapFloat[r2 + numDefine85];
                                                f1 = heapClassInst.heapFloat[r2 + numDefine25];
                                                f2 = heapClassInst.heapFloat[r2 + numDefine84];
                                                f3 = heapClassInst.heapFloat[r2 + numDefine21];
                                                f4 = heapClassInst.heapFloat[r2 + numDefine26];
                                                f5 = heapClassInst.heapFloat[r2 + numDefine22];
                                                f3 = f3 * f2;
                                                f1 = f1 * f0;
                                                f6 = heapClassInst.heapFloat[r2 + numDefine86];
                                                f7 = heapClassInst.heapFloat[r2 + numDefine29];
                                                f8 = heapClassInst.heapFloat[r2 + numDefine30];
                                                f9 = heapClassInst.heapFloat[r2 + numDefine27];
                                                f10 = heapClassInst.heapFloat[r2 + numDefine23];
                                                f5 = f5 * f2;
                                                f4 = f4 * f0;
                                                f1 = f3 + f1;
                                                f3 = f7 * f6;
                                                f7 = heapClassInst.heapFloat[r2 + numDefine87];
                                                f11 = heapClassInst.heapFloat[r2 + numDefine33];
                                                f12 = heapClassInst.heapFloat[r2 + numDefine35];
                                                f13 = heapClassInst.heapFloat[r2 + numDefine34];
                                                f14 = heapClassInst.heapFloat[r2 + numDefine31];
                                                f10 = f10 * f2;
                                                f9 = f9 * f0;
                                                f4 = f5 + f4;
                                                f5 = f8 * f6;
                                                f1 = f1 + f3;
                                                f3 = f11 * f7;
                                                f8 = f10 + f9;
                                                f9 = f14 * f6;
                                                f4 = f4 + f5;
                                                f5 = f13 * f7;
                                                f1 = f1 + f3;
                                                f3 = f8 + f9;
                                                f8 = f12 * f7;
                                                f4 = f4 + f5;
                                                heapClassInst.heapFloat[r2 + numDefine61] = f1;
                                                f3 = f3 + f8;
                                                heapClassInst.heapFloat[r2 + numDefine62] = f4;
                                                heapClassInst.heapFloat[r2 + numDefine63] = f3;
                                                heapClassInst.heap32[r2 + numDefine64] = 0;
                                                f5 = heapClassInst.heapFloat[r2 + numDefine45];
                                                f8 = heapClassInst.heapFloat[r2 + numDefine41];
                                                f9 = heapClassInst.heapFloat[r2 + numDefine49];
                                                f10 = heapClassInst.heapFloat[r2 + numDefine46];
                                                f11 = heapClassInst.heapFloat[r2 + numDefine42];
                                                f8 = f8 * f2;
                                                f5 = f5 * f0;
                                                f12 = heapClassInst.heapFloat[r2 + numDefine53];
                                                f13 = heapClassInst.heapFloat[r2 + numDefine50];
                                                f14 = heapClassInst.heapFloat[r2 + numDefine47];
                                                f15 = heapClassInst.heapFloat[r2 + numDefine43];
                                                f11 = f11 * f2;
                                                f10 = f10 * f0;
                                                f5 = f8 + f5;
                                                f8 = f9 * f6;
                                                f9 = heapClassInst.heapFloat[r2 + numDefine55];
                                                f16 = heapClassInst.heapFloat[r2 + numDefine54];
                                                f17 = heapClassInst.heapFloat[r2 + numDefine51];
                                                f2 = f15 * f2;
                                                f0 = f14 * f0;
                                                f10 = f11 + f10;
                                                f11 = f13 * f6;
                                                f5 = f5 + f8;
                                                f8 = f12 * f7;
                                                f5 = f5 + f8;
                                                f0 = f2 + f0;
                                                f2 = f17 * f6;
                                                f6 = f10 + f11;
                                                f8 = f16 * f7;
                                                f6 = f6 + f8;
                                                heapClassInst.heapFloat[r2 + numDefine65] = f5;
                                                f0 = f0 + f2;
                                                f2 = f9 * f7;
                                                f0 = f0 + f2;
                                                heapClassInst.heapFloat[r2 + numDefine66] = f6;
                                                heapClassInst.heapFloat[r2 + numDefine67] = f0;
                                                f1 = f1 - f5;
                                                heapClassInst.heap32[r2 + numDefine68] = 0;
                                                f2 = f4 - f6;
                                                heapClassInst.heapFloat[r2 + numDefine69] = f1;
                                                f0 = f3 - f0;
                                                heapClassInst.heapFloat[r2 + numDefine70] = f2;
                                                heapClassInst.heapFloat[r2 + numDefine71] = f0;
                                                heapClassInst.heap32[r2 + numDefine72] = 0;
                                                r3 = (r0 + numDefine332) | 0;
                                                heapClassInst.heap32[g0] = r0;
                                                heapClassInst.heap32[g0 + 1] = r3;
                                                zn22btVoronoiSimplexSolver14reduceVerticesERK15btUsageBitfield(i7);
                                                f0 = heapClassInst.heapFloat[r2 + numDefine84];
                                                f1 = 0;
                                                if (f0 >= f1) {
                                                    f0 = heapClassInst.heapFloat[r2 + numDefine85];
                                                    if (f0 < f1) {
                                                        break repeat5;
                                                    } else {
                                                        f0 = heapClassInst.heapFloat[r2 + numDefine86];
                                                        if (f0 < f1) {
                                                            break repeat5;
                                                        } else {
                                                            f0 = heapClassInst.heapFloat[r2 + numDefine87];

                                                            r1 = f0 >= f1 ? 1 : 0;
                                                            r1 = r1 & 1;
                                                            break repeat5;
                                                        }
                                                    }
                                                } else {
                                                    break repeat5;
                                                }
                                            }
                                        }
                                    }
                                    r2 = 1;
                                    heapClassInst.heap8[r0 + numDefine352] = (byte) r2;
                                    r2 = 0;
                                    heapClassInst.heap8[r0 + numDefine312] = (byte) r2;
                                    commonVariable.rg0 = r2;
                                    return;
                                } else {
                                    label = numDefine8;
                                    break repeat3;
                                }
                            }
                        }
                    } while (false);
                    heapClassInst.heap8[r0 + numDefine312] = (byte) r1;
                    r0 = r1 & numDefine255;
                    commonVariable.rg0 = r0;
                    return;
                } else {
                    if (r5 == 0) {
                        label = numDefine8;
                    } else {
                        if (r5 == 1) {
                            f0 = heapClassInst.heapFloat[r2 + numDefine21];
                            heapClassInst.heapFloat[r2 + numDefine61] = f0;
                            f1 = heapClassInst.heapFloat[r2 + numDefine22];
                            heapClassInst.heapFloat[r2 + numDefine62] = f1;
                            f2 = heapClassInst.heapFloat[r2 + numDefine23];
                            heapClassInst.heapFloat[r2 + numDefine63] = f2;
                            heapClassInst.heap32[r2 + numDefine64] = heapClassInst.heap32[r2 + numDefine24];
                            f3 = heapClassInst.heapFloat[r2 + numDefine41];
                            heapClassInst.heapFloat[r2 + numDefine65] = f3;
                            f4 = heapClassInst.heapFloat[r2 + numDefine42];
                            heapClassInst.heapFloat[r2 + numDefine66] = f4;
                            f5 = heapClassInst.heapFloat[r2 + numDefine43];
                            heapClassInst.heapFloat[r2 + numDefine67] = f5;
                            f0 = f0 - f3;
                            heapClassInst.heap32[r2 + numDefine68] = heapClassInst.heap32[r2 + numDefine44];
                            f1 = f1 - f4;
                            heapClassInst.heapFloat[r2 + numDefine69] = f0;
                            f0 = f2 - f5;
                            heapClassInst.heapFloat[r2 + numDefine70] = f1;
                            heapClassInst.heapFloat[r2 + numDefine71] = f0;
                            r1 = 0;
                            heapClassInst.heap32[r2 + numDefine72] = 0;
                            heapClassInst.heap8[r0 + numDefine352] = (byte) r1;
                            heapClassInst.heap8[r0 + numDefine332] = (byte) r4;
                            heapClassInst.heap32[r2 + numDefine84] = numDefine53216;
                            heapClassInst.heap32[r2 + numDefine85] = 0;
                            heapClassInst.heap32[r2 + numDefine86] = 0;
                            heapClassInst.heap32[r2 + numDefine87] = 0;
                            r1 = 1;
                            label = numDefine9;
                        } else {
                            label = numDefine8;
                        }
                    }
                }
            } while (false);
            if (label == numDefine8) {
                r1 = 0;
            }
            heapClassInst.heap8[r0 + numDefine312] = (byte) r1;
            commonVariable.rg0 = r1;
            return;
        } else {
            r0 = heapClassInst.heapU8[r0 + numDefine312];
            commonVariable.rg0 = r0;
            return;
        }
    }

    public static void zn16btCollisionWorld27ClosestConvexResultCallbackD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztvn16btCollisionWorld27ClosestConvexResultCallbackE;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn16btCollisionWorld27ClosestConvexResultCallbackD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztvn16btCollisionWorld27ClosestConvexResultCallbackE;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn16btCollisionWorld27ClosestConvexResultCallback15addSingleResultERNS17LocalConvexResultEb(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[fp];
        f0 = heapClassInst.heapFloat[r0 + numDefine10];
        r1 = r1 >> numDefine2;
        f1 = heapClassInst.heapFloat[r1 + 1];
        if (f0 <= f1) {
            r2 = heapClassInst.heap32[fp + numDefine2];
            heapClassInst.heapFloat[r1 + 1] = f0;
            r3 = heapClassInst.heap32[r0];
            heapClassInst.heap32[r1 + numDefine19] = r3;
            if (r2 == 0) {
                r2 = r3 >> numDefine2;
                f0 = heapClassInst.heapFloat[r0 + numDefine2];
                f1 = heapClassInst.heapFloat[r2 + 1];
                f2 = heapClassInst.heapFloat[r0 + numDefine3];
                f3 = heapClassInst.heapFloat[r2 + numDefine2];
                f4 = heapClassInst.heapFloat[r2 + numDefine5];
                f5 = heapClassInst.heapFloat[r2 + numDefine6];
                f1 = f1 * f0;
                f3 = f3 * f2;
                f6 = heapClassInst.heapFloat[r0 + numDefine4];
                f7 = heapClassInst.heapFloat[r2 + numDefine3];
                f8 = heapClassInst.heapFloat[r2 + numDefine9];
                f9 = heapClassInst.heapFloat[r2 + numDefine10];
                f10 = heapClassInst.heapFloat[r2 + numDefine11];
                f11 = heapClassInst.heapFloat[r2 + numDefine7];
                f4 = f4 * f0;
                f5 = f5 * f2;
                f1 = f1 + f3;
                f3 = f7 * f6;
                f0 = f8 * f0;
                f2 = f9 * f2;
                f4 = f4 + f5;
                f5 = f11 * f6;
                f1 = f1 + f3;
                f0 = f0 + f2;
                f2 = f10 * f6;
                f3 = f4 + f5;
                heapClassInst.heapFloat[r1 + numDefine11] = f1;
                f0 = f0 + f2;
                heapClassInst.heapFloat[r1 + numDefine12] = f3;
                heapClassInst.heapFloat[r1 + numDefine13] = f0;
                heapClassInst.heap32[r1 + numDefine14] = 0;
            } else {
                heapClassInst.heap32[r1 + numDefine11] = heapClassInst.heap32[r0 + numDefine2];
                heapClassInst.heap32[r1 + numDefine12] = heapClassInst.heap32[r0 + numDefine3];
                heapClassInst.heap32[r1 + numDefine13] = heapClassInst.heap32[r0 + numDefine4];
                heapClassInst.heap32[r1 + numDefine14] = heapClassInst.heap32[r0 + numDefine5];
            }
            heapClassInst.heap32[r1 + numDefine15] = heapClassInst.heap32[r0 + numDefine6];
            heapClassInst.heap32[r1 + numDefine16] = heapClassInst.heap32[r0 + numDefine7];
            heapClassInst.heap32[r1 + numDefine17] = heapClassInst.heap32[r0 + numDefine8];
            heapClassInst.heap32[r1 + numDefine18] = heapClassInst.heap32[r0 + numDefine9];
            f0 = heapClassInst.heapFloat[r0 + numDefine10];
            commonVariable.fg0 = f0;
            return;
        } else {
            r0 = twoEStr36;
            r1 = twoEStr4;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine384;
            assertNew(i7);
        }
    }

    public static void znk21btConeTwistConstraint28calculateSerializeBufferSizeEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = numDefine204;
        commonVariable.rg0 = r0;
        return;
    }

    public static void znk21btConeTwistConstraint9serializeEPvP12btSerializer(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = r2;
        r1 = r1 >> numDefine2;
        r0 = r0 >> numDefine2;
        znk17btTypedConstraint9serializeEPvP12btSerializer(i7);
        heapClassInst.heap32[r1 + numDefine11] = heapClassInst.heap32[r0 + numDefine72];
        heapClassInst.heap32[r1 + numDefine12] = heapClassInst.heap32[r0 + numDefine73];
        heapClassInst.heap32[r1 + numDefine13] = heapClassInst.heap32[r0 + numDefine74];
        heapClassInst.heap32[r1 + numDefine14] = heapClassInst.heap32[r0 + numDefine75];
        heapClassInst.heap32[r1 + numDefine15] = heapClassInst.heap32[r0 + numDefine76];
        heapClassInst.heap32[r1 + numDefine16] = heapClassInst.heap32[r0 + numDefine77];
        heapClassInst.heap32[r1 + numDefine17] = heapClassInst.heap32[r0 + numDefine78];
        heapClassInst.heap32[r1 + numDefine18] = heapClassInst.heap32[r0 + numDefine79];
        heapClassInst.heap32[r1 + numDefine19] = heapClassInst.heap32[r0 + numDefine80];
        heapClassInst.heap32[r1 + numDefine20] = heapClassInst.heap32[r0 + numDefine81];
        heapClassInst.heap32[r1 + numDefine21] = heapClassInst.heap32[r0 + numDefine82];
        heapClassInst.heap32[r1 + numDefine22] = heapClassInst.heap32[r0 + numDefine83];
        heapClassInst.heap32[r1 + numDefine23] = heapClassInst.heap32[r0 + numDefine84];
        heapClassInst.heap32[r1 + numDefine24] = heapClassInst.heap32[r0 + numDefine85];
        heapClassInst.heap32[r1 + numDefine25] = heapClassInst.heap32[r0 + numDefine86];
        heapClassInst.heap32[r1 + numDefine26] = heapClassInst.heap32[r0 + numDefine87];
        heapClassInst.heap32[r1 + numDefine27] = heapClassInst.heap32[r0 + numDefine88];
        heapClassInst.heap32[r1 + numDefine28] = heapClassInst.heap32[r0 + numDefine89];
        heapClassInst.heap32[r1 + numDefine29] = heapClassInst.heap32[r0 + numDefine90];
        heapClassInst.heap32[r1 + numDefine30] = heapClassInst.heap32[r0 + numDefine91];
        heapClassInst.heap32[r1 + numDefine31] = heapClassInst.heap32[r0 + numDefine92];
        heapClassInst.heap32[r1 + numDefine32] = heapClassInst.heap32[r0 + numDefine93];
        heapClassInst.heap32[r1 + numDefine33] = heapClassInst.heap32[r0 + numDefine94];
        heapClassInst.heap32[r1 + numDefine34] = heapClassInst.heap32[r0 + numDefine95];
        heapClassInst.heap32[r1 + numDefine35] = heapClassInst.heap32[r0 + numDefine96];
        heapClassInst.heap32[r1 + numDefine36] = heapClassInst.heap32[r0 + numDefine97];
        heapClassInst.heap32[r1 + numDefine37] = heapClassInst.heap32[r0 + numDefine98];
        heapClassInst.heap32[r1 + numDefine38] = heapClassInst.heap32[r0 + numDefine99];
        heapClassInst.heap32[r1 + numDefine39] = heapClassInst.heap32[r0 + numDefine100];
        heapClassInst.heap32[r1 + numDefine40] = heapClassInst.heap32[r0 + numDefine101];
        heapClassInst.heap32[r1 + numDefine41] = heapClassInst.heap32[r0 + numDefine102];
        heapClassInst.heap32[r1 + numDefine42] = heapClassInst.heap32[r0 + numDefine103];
        heapClassInst.heap32[r1 + numDefine43] = heapClassInst.heap32[r0 + numDefine108];
        heapClassInst.heap32[r1 + numDefine44] = heapClassInst.heap32[r0 + numDefine109];
        heapClassInst.heap32[r1 + numDefine45] = heapClassInst.heap32[r0 + numDefine110];
        heapClassInst.heap32[r1 + numDefine46] = heapClassInst.heap32[r0 + numDefine104];
        heapClassInst.heap32[r1 + numDefine47] = heapClassInst.heap32[r0 + numDefine105];
        heapClassInst.heap32[r1 + numDefine48] = heapClassInst.heap32[r0 + numDefine106];
        heapClassInst.heap32[r1 + numDefine49] = heapClassInst.heap32[r0 + numDefine107];
        r0 = twoEStr239;
        commonVariable.rg0 = r0;
        return;
    }

    public static void zn21btConeTwistConstraintD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv21btConeTwistConstraint;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn21btConeTwistConstraintD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv21btConeTwistConstraint;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn21btConeTwistConstraint13buildJacobianEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg216;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heapU8[r0 + numDefine515];
        if (!(r1 == 0)) {
            r1 = r0 >> numDefine2;
            heapClassInst.heap32[r1 + numDefine7] = 0;
            heapClassInst.heap32[r1 + numDefine127] = 0;
            heapClassInst.heap32[r1 + numDefine126] = 0;
            heapClassInst.heap32[r1 + numDefine141] = 0;
            heapClassInst.heap32[r1 + numDefine142] = 0;
            heapClassInst.heap32[r1 + numDefine143] = 0;
            heapClassInst.heap32[r1 + numDefine144] = 0;
            r2 = heapClassInst.heapU8[r0 + numDefine512];
            if (!(r2 != 0)) {
                r2 = heapClassInst.heap32[r1 + numDefine6];
                r3 = heapClassInst.heap32[r1 + numDefine5];
                r2 = r2 >> numDefine2;
                r3 = r3 >> numDefine2;
                f0 = heapClassInst.heapFloat[r2 + numDefine5];
                f1 = heapClassInst.heapFloat[r1 + numDefine100];
                f2 = heapClassInst.heapFloat[r2 + 1];
                f3 = heapClassInst.heapFloat[r2 + numDefine6];
                f4 = heapClassInst.heapFloat[r1 + numDefine101];
                f5 = heapClassInst.heapFloat[r2 + numDefine2];
                f6 = heapClassInst.heapFloat[r3 + numDefine5];
                f7 = heapClassInst.heapFloat[r1 + numDefine84];
                f8 = heapClassInst.heapFloat[r3 + 1];
                f9 = heapClassInst.heapFloat[r3 + numDefine6];
                f10 = heapClassInst.heapFloat[r1 + numDefine85];
                f11 = heapClassInst.heapFloat[r3 + numDefine2];
                f12 = heapClassInst.heapFloat[r2 + numDefine9];
                f13 = heapClassInst.heapFloat[r2 + numDefine10];
                f14 = heapClassInst.heapFloat[r3 + numDefine9];
                f15 = heapClassInst.heapFloat[r3 + numDefine10];
                f0 = f0 * f1;
                f3 = f3 * f4;
                f16 = heapClassInst.heapFloat[r2 + numDefine7];
                f17 = heapClassInst.heapFloat[r1 + numDefine102];
                f18 = heapClassInst.heapFloat[r2 + numDefine3];
                f6 = f6 * f7;
                f9 = f9 * f10;
                f19 = heapClassInst.heapFloat[r3 + numDefine7];
                f20 = heapClassInst.heapFloat[r1 + numDefine86];
                f21 = heapClassInst.heapFloat[r3 + numDefine3];
                f2 = f2 * f1;
                f5 = f5 * f4;
                f8 = f8 * f7;
                f11 = f11 * f10;
                f22 = heapClassInst.heapFloat[r2 + numDefine11];
                f23 = heapClassInst.heapFloat[r3 + numDefine11];
                f1 = f12 * f1;
                f4 = f13 * f4;
                f7 = f14 * f7;
                f10 = f15 * f10;
                f0 = f0 + f3;
                f3 = f16 * f17;
                f6 = f6 + f9;
                f9 = f19 * f20;
                f2 = f2 + f5;
                f5 = f18 * f17;
                f8 = f8 + f11;
                f11 = f21 * f20;
                f1 = f1 + f4;
                f4 = f22 * f17;
                f7 = f7 + f10;
                f10 = f23 * f20;
                f0 = f0 + f3;
                f3 = heapClassInst.heapFloat[r2 + numDefine14];
                f6 = f6 + f9;
                f9 = heapClassInst.heapFloat[r3 + numDefine14];
                f2 = f2 + f5;
                f5 = heapClassInst.heapFloat[r2 + numDefine13];
                f8 = f8 + f11;
                f11 = heapClassInst.heapFloat[r3 + numDefine13];
                f0 = f0 + f3;
                f3 = f6 + f9;
                f2 = f2 + f5;
                f5 = f8 + f11;
                f1 = f1 + f4;
                f4 = heapClassInst.heapFloat[r2 + numDefine15];
                f6 = f7 + f10;
                f7 = heapClassInst.heapFloat[r3 + numDefine15];
                f8 = f0 - f3;
                f9 = f2 - f5;
                f1 = f1 + f4;
                f4 = f6 + f7;
                f6 = f1 - f4;
                f7 = f9 * f9;
                f10 = f8 * f8;
                f7 = f7 + f10;
                f10 = f6 * f6;
                f7 = f7 + f10;
                f10 = (float) numDefineFloat1257;
                if (f7 > f10) {
                    heapClassInst.heapFloat[g0] = f7;
                    f10 = 1;
                    sqrtf(i7);
                    f11 = (float) (f10 / commonVariable.fg0);
                    r2 = sp + numDefineNeg176;
                    f7 = f9 * f11;
                    f8 = f8 * f11;
                    r3 = r2 >> numDefine2;
                    heapClassInst.heapFloat[fp + numDefineNeg44] = f7;
                    f6 = f6 * f11;
                    heapClassInst.heapFloat[r3 + 1] = f8;
                    r2 = (r2 + numDefine8) | 0;
                    heapClassInst.heapFloat[r3 + numDefine2] = f6;
                    heapClassInst.heap32[r3 + numDefine3] = 0;
                    f9 = 0;
                    if (f6 < f9) {
                        f9 = -f6;
                    } else {
                        f9 = f6;
                    }
                    f11 = (float) numDefineFloat742;
                    if (f9 > f11) {
                        f7 = f8 * f8;
                        f8 = f6 * f6;
                        f7 = f7 + f8;
                        heapClassInst.heapFloat[g0] = f7;
                        sqrtf(i7);
                        heapClassInst.heap32[r3 + numDefine4] = 0;
                        f6 = heapClassInst.heapFloat[r3 + numDefine2];
                        f8 = (float) (f10 / commonVariable.fg0);
                        f6 = -f6;
                        f6 = f8 * f6;
                        heapClassInst.heapFloat[r3 + numDefine5] = f6;
                        f9 = heapClassInst.heapFloat[r3 + 1];
                        f9 = f9 * f8;
                        f7 = f7 * f8;
                        heapClassInst.heapFloat[r3 + numDefine6] = f9;
                        heapClassInst.heapFloat[r3 + numDefine8] = f7;
                        f7 = heapClassInst.heapFloat[fp + numDefineNeg44];
                        f8 = -f7;
                        f8 = f9 * f8;
                        f7 = f7 * f6;
                        heapClassInst.heapFloat[r3 + numDefine9] = f8;
                        heapClassInst.heapFloat[r3 + numDefine10] = f7;
                        label = numDefine10;
                    } else {
                        label = numDefine9;
                    }
                } else {
                    r2 = sp + numDefineNeg176;
                    r3 = r2 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg44] = numDefine53216;
                    heapClassInst.heap32[r3 + 1] = 0;
                    r2 = (r2 + numDefine8) | 0;
                    f7 = 1;
                    f8 = 0;
                    heapClassInst.heap32[r3 + numDefine2] = 0;
                    heapClassInst.heap32[r3 + numDefine3] = 0;
                    label = numDefine9;
                }
                if (label == numDefine9) {
                    f6 = f7 * f7;
                    f7 = f8 * f8;
                    f6 = f6 + f7;
                    r3 = sp + numDefineNeg176;
                    heapClassInst.heapFloat[g0] = f6;
                    r3 = r3 >> numDefine2;
                    sqrtf(i7);
                    f8 = 1;
                    f9 = heapClassInst.heapFloat[r3 + 1];
                    f7 = (float) (f8 / commonVariable.fg0);
                    f8 = -f9;
                    f8 = f7 * f8;
                    heapClassInst.heapFloat[r3 + numDefine4] = f8;
                    f9 = heapClassInst.heapFloat[fp + numDefineNeg44];
                    f9 = f9 * f7;
                    heapClassInst.heapFloat[r3 + numDefine5] = f9;
                    r2 = r2 >> numDefine2;
                    heapClassInst.heap32[r3 + numDefine6] = 0;
                    f10 = heapClassInst.heapFloat[r2];
                    f11 = -f10;
                    f9 = f9 * f11;
                    f8 = f10 * f8;
                    heapClassInst.heapFloat[r3 + numDefine8] = f9;
                    f6 = f6 * f7;
                    heapClassInst.heapFloat[r3 + numDefine9] = f8;
                    heapClassInst.heapFloat[r3 + numDefine10] = f6;
                }
                r2 = (r0 + numDefine36) | 0;
                r3 = 0;
                repeat16: while (true) {
                    r4 = heapClassInst.heap32[r1 + numDefine5];
                    r5 = r4 >> numDefine2;
                    r6 = sp + numDefineNeg128;
                    r7 = r6 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg32] = heapClassInst.heap32[r5 + 1];
                    heapClassInst.heap32[r7 + 1] = heapClassInst.heap32[r5 + numDefine5];
                    heapClassInst.heap32[r7 + numDefine2] = heapClassInst.heap32[r5 + numDefine9];
                    heapClassInst.heap32[r7 + numDefine3] = 0;
                    heapClassInst.heap32[r7 + numDefine4] = heapClassInst.heap32[r5 + numDefine2];
                    heapClassInst.heap32[r7 + numDefine5] = heapClassInst.heap32[r5 + numDefine6];
                    heapClassInst.heap32[r7 + numDefine6] = heapClassInst.heap32[r5 + numDefine10];
                    heapClassInst.heap32[r7 + numDefine7] = 0;
                    heapClassInst.heap32[r7 + numDefine8] = heapClassInst.heap32[r5 + numDefine3];
                    heapClassInst.heap32[r7 + numDefine9] = heapClassInst.heap32[r5 + numDefine7];
                    heapClassInst.heap32[r7 + numDefine10] = heapClassInst.heap32[r5 + numDefine11];
                    heapClassInst.heap32[r7 + numDefine11] = 0;
                    r7 = heapClassInst.heap32[r1 + numDefine6];
                    r8 = sp + numDefineNeg80;
                    r9 = r7 >> numDefine2;
                    r10 = r8 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg20] = heapClassInst.heap32[r9 + 1];
                    heapClassInst.heap32[r10 + 1] = heapClassInst.heap32[r9 + numDefine5];
                    heapClassInst.heap32[r10 + numDefine2] = heapClassInst.heap32[r9 + numDefine9];
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    heapClassInst.heap32[r10 + numDefine4] = heapClassInst.heap32[r9 + numDefine2];
                    heapClassInst.heap32[r10 + numDefine5] = heapClassInst.heap32[r9 + numDefine6];
                    heapClassInst.heap32[r10 + numDefine6] = heapClassInst.heap32[r9 + numDefine10];
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    heapClassInst.heap32[r10 + numDefine8] = heapClassInst.heap32[r9 + numDefine3];
                    heapClassInst.heap32[r10 + numDefine9] = heapClassInst.heap32[r9 + numDefine7];
                    heapClassInst.heap32[r10 + numDefine10] = heapClassInst.heap32[r9 + numDefine11];
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    f6 = heapClassInst.heapFloat[r5 + numDefine13];
                    f7 = heapClassInst.heapFloat[r5 + numDefine15];
                    f8 = heapClassInst.heapFloat[r5 + numDefine14];
                    r10 = sp + numDefineNeg32;
                    f6 = f5 - f6;
                    r11 = r10 >> numDefine2;
                    f8 = f3 - f8;
                    heapClassInst.heapFloat[fp + numDefineNeg8] = f6;
                    f6 = f4 - f7;
                    heapClassInst.heapFloat[r11 + 1] = f8;
                    heapClassInst.heapFloat[r11 + numDefine2] = f6;
                    heapClassInst.heap32[r11 + numDefine3] = 0;
                    f6 = heapClassInst.heapFloat[r9 + numDefine13];
                    f7 = heapClassInst.heapFloat[r9 + numDefine15];
                    f8 = heapClassInst.heapFloat[r9 + numDefine14];
                    r11 = sp + numDefineNeg16;
                    f6 = f2 - f6;
                    r12 = r11 >> numDefine2;
                    f8 = f0 - f8;
                    heapClassInst.heapFloat[fp + numDefineNeg4] = f6;
                    f6 = f1 - f7;
                    heapClassInst.heapFloat[r12 + 1] = f8;
                    heapClassInst.heapFloat[r12 + numDefine2] = f6;
                    heapClassInst.heap32[r12 + numDefine3] = 0;
                    f6 = heapClassInst.heapFloat[r9 + numDefine84];
                    f7 = heapClassInst.heapFloat[r5 + numDefine84];
                    r5 = sp + numDefineNeg176;
                    r5 = (r5 + r3) | 0;
                    r4 = (r4 + numDefine388) | 0;
                    r7 = (r7 + numDefine388) | 0;
                    heapClassInst.heap32[g0] = r2;
                    heapClassInst.heap32[g0 + 1] = r6;
                    heapClassInst.heap32[g0 + numDefine2] = r8;
                    heapClassInst.heap32[g0 + numDefine3] = r10;
                    heapClassInst.heap32[g0 + numDefine4] = r11;
                    heapClassInst.heap32[g0 + numDefine5] = r5;
                    heapClassInst.heap32[g0 + numDefine6] = r4;
                    heapClassInst.heapFloat[g0 + numDefine7] = f7;
                    heapClassInst.heap32[g0 + numDefine8] = r7;
                    heapClassInst.heapFloat[g0 + numDefine9] = f6;
                    r3 = (r3 + numDefine16) | 0;
                    r2 = (r2 + numDefine84) | 0;
                    zn15btJacobianEntryC2ERK11btMatrix3x3S2RK9btVector3S5S5S5FS5F(i7);
                    if (!(r3 != numDefine48)) {
                        break repeat16;
                    }
                }
            }
            r2 = heapClassInst.heap32[r1 + numDefine6];
            r1 = heapClassInst.heap32[r1 + numDefine5];
            r3 = (r1 + numDefine4) | 0;
            r4 = (r2 + numDefine4) | 0;
            r1 = (r1 + numDefine256) | 0;
            r2 = (r2 + numDefine256) | 0;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r3;
            heapClassInst.heap32[g0 + numDefine2] = r4;
            heapClassInst.heap32[g0 + numDefine3] = r1;
            heapClassInst.heap32[g0 + numDefine4] = r2;
            zn21btConeTwistConstraint14calcAngleInfo2ERK11btTransformS2RK11btMatrix3x3S5(i7);
        }
        return;
    }

    public static void zn21btConeTwistConstraint8getInfo1EPN17btTypedConstraint17btConstraintInfo1E(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heapU8[r0 + numDefine515];
        if (r2 == 0) {
            r1 = r1 >> numDefine2;
            heapClassInst.heap32[r1] = numDefine3;
            r2 = r0 >> numDefine2;
            heapClassInst.heap32[r1 + 1] = numDefine3;
            r3 = heapClassInst.heap32[r2 + numDefine6];
            r4 = heapClassInst.heap32[r2 + numDefine5];
            r5 = (r4 + numDefine4) | 0;
            r6 = (r3 + numDefine4) | 0;
            r4 = (r4 + numDefine256) | 0;
            r3 = (r3 + numDefine256) | 0;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r5;
            heapClassInst.heap32[g0 + numDefine2] = r6;
            heapClassInst.heap32[g0 + numDefine3] = r4;
            heapClassInst.heap32[g0 + numDefine4] = r3;
            zn21btConeTwistConstraint14calcAngleInfo2ERK11btTransformS2RK11btMatrix3x3S5(i7);
            r3 = heapClassInst.heapU8[r0 + numDefine514];
            if (!(r3 == 0)) {
                r3 = heapClassInst.heap32[r1];
                r4 = (r3 + 1) | 0;
                heapClassInst.heap32[r1] = r4;
                r4 = heapClassInst.heap32[r1 + 1];
                r5 = (r4 + -1) | 0;
                heapClassInst.heap32[r1 + 1] = r5;
                f0 = heapClassInst.heapFloat[r2 + numDefine111];
                f1 = heapClassInst.heapFloat[r2 + numDefine108];
                if (!(f1 >= f0)) {
                    f1 = heapClassInst.heapFloat[r2 + numDefine109];
                    if (!(f1 >= f0)) {
                        r2 = (r3 + numDefine2) | 0;
                        r3 = (r4 + numDefineNeg2) | 0;
                        heapClassInst.heap32[r1] = r2;
                        heapClassInst.heap32[r1 + 1] = r3;
                    }
                }
            }
            r0 = heapClassInst.heapU8[r0 + numDefine513];
            if (!(r0 == 0)) {
                r0 = heapClassInst.heap32[r1];
                r0 = (r0 + 1) | 0;
                heapClassInst.heap32[r1] = r0;
                r0 = heapClassInst.heap32[r1 + 1];
                r0 = (r0 + -1) | 0;
                heapClassInst.heap32[r1 + 1] = r0;
            }
            return;
        } else {
            r0 = r1 >> numDefine2;
            heapClassInst.heap32[r0] = 0;
            heapClassInst.heap32[r0 + 1] = 0;
            return;
        }
    }

    public static void zn21btConeTwistConstraint8getInfo2EPN17btTypedConstraint17btConstraintInfo2E(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg24;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[r1 + numDefine6];
        r3 = heapClassInst.heap32[r1 + numDefine5];
        r4 = (r3 + numDefine4) | 0;
        r5 = (r2 + numDefine4) | 0;
        r6 = (r3 + numDefine256) | 0;
        r7 = (r2 + numDefine256) | 0;
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r4;
        heapClassInst.heap32[g0 + numDefine2] = r5;
        heapClassInst.heap32[g0 + numDefine3] = r6;
        heapClassInst.heap32[g0 + numDefine4] = r7;
        zn21btConeTwistConstraint14calcAngleInfo2ERK11btTransformS2RK11btMatrix3x3S5(i7);
        r4 = heapClassInst.heapU8[r0 + numDefine515];
        if (r4 == 0) {
            r4 = heapClassInst.heap32[fp + 1];
            r5 = r4 >> numDefine2;
            r6 = heapClassInst.heap32[r5 + numDefine2];
            r6 = r6 >> numDefine2;
            heapClassInst.heap32[r6] = numDefine53216;
            r6 = heapClassInst.heap32[r5 + numDefine6];
            r7 = heapClassInst.heap32[r5 + numDefine2];
            r6 = r6 << numDefine2;
            r6 = (r6 + r7) | 0;
            r6 = r6 >> numDefine2;
            heapClassInst.heap32[r6 + 1] = numDefine53216;
            r6 = heapClassInst.heap32[r5 + numDefine6];
            r7 = heapClassInst.heap32[r5 + numDefine2];
            r6 = r6 << numDefine3;
            r6 = (r6 + r7) | 0;
            r6 = r6 >> numDefine2;
            heapClassInst.heap32[r6 + numDefine2] = numDefine53216;
            r3 = r3 >> numDefine2;
            f0 = heapClassInst.heapFloat[r3 + numDefine9];
            f1 = heapClassInst.heapFloat[r1 + numDefine84];
            f2 = heapClassInst.heapFloat[r3 + numDefine5];
            f3 = heapClassInst.heapFloat[r3 + numDefine10];
            f4 = heapClassInst.heapFloat[r1 + numDefine85];
            f5 = heapClassInst.heapFloat[r3 + numDefine6];
            r6 = heapClassInst.heap32[r5 + numDefine6];
            f6 = heapClassInst.heapFloat[r3 + 1];
            f7 = heapClassInst.heapFloat[r3 + numDefine2];
            r7 = heapClassInst.heap32[r5 + numDefine3];
            f2 = f2 * f1;
            f5 = f5 * f4;
            f0 = f0 * f1;
            f3 = f3 * f4;
            f8 = heapClassInst.heapFloat[r3 + numDefine11];
            f9 = heapClassInst.heapFloat[r1 + numDefine86];
            f10 = heapClassInst.heapFloat[r3 + numDefine7];
            f11 = heapClassInst.heapFloat[r3 + numDefine3];
            f2 = f2 + f5;
            f5 = f10 * f9;
            r8 = r7 >> numDefine2;
            f0 = f0 + f3;
            f3 = f8 * f9;
            f2 = f2 + f5;
            f0 = f0 + f3;
            heapClassInst.heap32[r8] = 0;
            r9 = r6 << numDefine2;
            f3 = -f2;
            heapClassInst.heapFloat[r8 + 1] = f0;
            r9 = (r7 + r9) | 0;
            heapClassInst.heapFloat[r8 + numDefine2] = f3;
            r9 = r9 >> numDefine2;
            f1 = f6 * f1;
            f3 = f7 * f4;
            f4 = -f0;
            heapClassInst.heap32[r8 + numDefine3] = 0;
            heapClassInst.heapFloat[r9] = f4;
            f1 = f1 + f3;
            f3 = f11 * f9;
            r6 = r6 << numDefine3;
            f1 = f1 + f3;
            heapClassInst.heap32[r9 + 1] = 0;
            r8 = (r6 + r7) | 0;
            r6 = r6 | numDefine4;
            heapClassInst.heapFloat[r9 + numDefine2] = f1;
            r6 = (r7 + r6) | 0;
            r7 = r8 >> numDefine2;
            heapClassInst.heap32[r9 + numDefine3] = 0;
            r6 = r6 >> numDefine2;
            f3 = -f1;
            heapClassInst.heapFloat[r7] = f2;
            heapClassInst.heapFloat[r6] = f3;
            heapClassInst.heap32[r7 + numDefine2] = 0;
            heapClassInst.heap32[r7 + numDefine3] = 0;
            r2 = r2 >> numDefine2;
            f3 = heapClassInst.heapFloat[r2 + numDefine9];
            f4 = heapClassInst.heapFloat[r1 + numDefine100];
            f5 = heapClassInst.heapFloat[r2 + numDefine10];
            f6 = heapClassInst.heapFloat[r1 + numDefine101];
            f3 = f3 * f4;
            f5 = f5 * f6;
            f7 = heapClassInst.heapFloat[r2 + numDefine11];
            f8 = heapClassInst.heapFloat[r1 + numDefine102];
            r6 = heapClassInst.heap32[r5 + numDefine6];
            f9 = heapClassInst.heapFloat[r2 + numDefine5];
            f10 = heapClassInst.heapFloat[r2 + numDefine6];
            f11 = heapClassInst.heapFloat[r2 + numDefine7];
            f12 = heapClassInst.heapFloat[r2 + 1];
            f13 = heapClassInst.heapFloat[r2 + numDefine2];
            f14 = heapClassInst.heapFloat[r2 + numDefine3];
            r7 = heapClassInst.heap32[r5 + numDefine5];
            f3 = f3 + f5;
            f5 = f7 * f8;
            f3 = f3 + f5;
            r8 = r7 >> numDefine2;
            f5 = f9 * f4;
            f7 = f10 * f6;
            f5 = f5 + f7;
            f7 = f11 * f8;
            f9 = -f3;
            heapClassInst.heap32[r8] = 0;
            f5 = f5 + f7;
            r9 = r6 << numDefine2;
            heapClassInst.heapFloat[r8 + 1] = f9;
            r9 = (r7 + r9) | 0;
            heapClassInst.heapFloat[r8 + numDefine2] = f5;
            f4 = f12 * f4;
            f6 = f13 * f6;
            f4 = f4 + f6;
            f6 = f14 * f8;
            r9 = r9 >> numDefine2;
            heapClassInst.heap32[r8 + numDefine3] = 0;
            f4 = f4 + f6;
            heapClassInst.heapFloat[r9] = f3;
            r6 = r6 << numDefine3;
            f6 = -f4;
            heapClassInst.heap32[r9 + 1] = 0;
            r8 = (r6 + r7) | 0;
            r6 = r6 | numDefine4;
            heapClassInst.heapFloat[r9 + numDefine2] = f6;
            r6 = (r7 + r6) | 0;
            r7 = r8 >> numDefine2;
            f6 = -f5;
            heapClassInst.heap32[r9 + numDefine3] = 0;
            r6 = r6 >> numDefine2;
            heapClassInst.heapFloat[r7] = f6;
            heapClassInst.heapFloat[r6] = f4;
            heapClassInst.heap32[r7 + numDefine2] = 0;
            heapClassInst.heap32[r7 + numDefine3] = 0;
            r6 = heapClassInst.heapU8[r0 + numDefine580];
            r6 = r6 & numDefine2;
            if (r6 == 0) {
                r4 = (r4 + numDefine4) | 0;
            } else {
                r4 = (r0 + numDefine588) | 0;
            }
            f6 = heapClassInst.heapFloat[r2 + numDefine13];
            r4 = r4 >> numDefine2;
            f4 = f4 + f6;
            f1 = f4 - f1;
            f4 = heapClassInst.heapFloat[r3 + numDefine13];
            f6 = heapClassInst.heapFloat[r4];
            f7 = heapClassInst.heapFloat[r5];
            r4 = heapClassInst.heap32[r5 + numDefine7];
            f6 = f7 * f6;
            f1 = f1 - f4;
            r4 = r4 >> numDefine2;
            f1 = f1 * f6;
            heapClassInst.heapFloat[r4] = f1;
            r4 = heapClassInst.heap32[r5 + numDefine9];
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r4] = numDefineNeg88609;
            r4 = heapClassInst.heap32[r5 + numDefine10];
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r4] = numDefine95039;
            r4 = heapClassInst.heapU8[r0 + numDefine580];
            r4 = r4 & 1;
            if (!(r4 == 0)) {
                r4 = heapClassInst.heap32[r5 + numDefine8];
                r4 = r4 >> numDefine2;
                heapClassInst.heap32[r4] = heapClassInst.heap32[r1 + numDefine146];
            }
            f1 = heapClassInst.heapFloat[r2 + numDefine14];
            r4 = heapClassInst.heap32[r5 + numDefine6];
            f1 = f5 + f1;
            r4 = r4 << numDefine2;
            r6 = heapClassInst.heap32[r5 + numDefine7];
            f4 = heapClassInst.heapFloat[r3 + numDefine14];
            f1 = f1 - f2;
            r4 = (r6 + r4) | 0;
            f1 = f1 - f4;
            r4 = r4 >> numDefine2;
            f1 = f1 * f6;
            heapClassInst.heapFloat[r4] = f1;
            r4 = heapClassInst.heap32[r5 + numDefine6];
            r6 = heapClassInst.heap32[r5 + numDefine9];
            r4 = r4 << numDefine2;
            r4 = (r6 + r4) | 0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r4] = numDefineNeg88609;
            r4 = heapClassInst.heap32[r5 + numDefine6];
            r6 = heapClassInst.heap32[r5 + numDefine10];
            r4 = r4 << numDefine2;
            r4 = (r6 + r4) | 0;
            r4 = r4 >> numDefine2;
            heapClassInst.heap32[r4] = numDefine95039;
            r4 = heapClassInst.heapU8[r0 + numDefine580];
            r4 = r4 & 1;
            if (!(r4 == 0)) {
                r4 = heapClassInst.heap32[r5 + numDefine6];
                r6 = heapClassInst.heap32[r5 + numDefine8];
                r4 = r4 << numDefine2;
                r4 = (r6 + r4) | 0;
                r4 = r4 >> numDefine2;
                heapClassInst.heap32[r4] = heapClassInst.heap32[r1 + numDefine146];
            }
            f1 = heapClassInst.heapFloat[r2 + numDefine15];
            r2 = heapClassInst.heap32[r5 + numDefine6];
            f3 = f3 + f1;
            r2 = r2 << numDefine3;
            r4 = heapClassInst.heap32[r5 + numDefine7];
            f1 = heapClassInst.heapFloat[r3 + numDefine15];
            f0 = f3 - f0;
            r2 = (r4 + r2) | 0;
            f0 = f0 - f1;
            r2 = r2 >> numDefine2;
            f0 = f0 * f6;
            heapClassInst.heapFloat[r2] = f0;
            r2 = heapClassInst.heap32[r5 + numDefine6];
            r4 = heapClassInst.heap32[r5 + numDefine9];
            r2 = r2 << numDefine3;
            r2 = (r4 + r2) | 0;
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[r2] = numDefineNeg88609;
            r2 = heapClassInst.heap32[r5 + numDefine6];
            r4 = heapClassInst.heap32[r5 + numDefine10];
            r2 = r2 << numDefine3;
            r2 = (r4 + r2) | 0;
            r2 = r2 >> numDefine2;
            heapClassInst.heap32[r2] = numDefine95039;
            r2 = heapClassInst.heapU8[r0 + numDefine580];
            r2 = r2 & 1;
            if (!(r2 == 0)) {
                r2 = heapClassInst.heap32[r5 + numDefine6];
                r4 = heapClassInst.heap32[r5 + numDefine8];
                r2 = r2 << numDefine3;
                r2 = (r4 + r2) | 0;
                r2 = r2 >> numDefine2;
                heapClassInst.heap32[r2] = heapClassInst.heap32[r1 + numDefine146];
            }
            r2 = heapClassInst.heap32[r5 + numDefine6];
            r4 = (r2 * numDefine3) | 0;
            r6 = heapClassInst.heapU8[r0 + numDefine514];
            repeat16: do {
                if (r6 != 0) {
                    f0 = heapClassInst.heapFloat[r1 + numDefine111];
                    r6 = heapClassInst.heap32[r5 + numDefine3];
                    r7 = heapClassInst.heap32[r5 + numDefine5];
                    f3 = heapClassInst.heapFloat[r1 + numDefine108];
                    if (!(f3 >= f0)) {
                        f3 = heapClassInst.heapFloat[r1 + numDefine109];
                        if (!(f3 >= f0)) {
                            f0 = heapClassInst.heapFloat[r3 + 1];
                            f3 = heapClassInst.heapFloat[r1 + numDefine73];
                            f6 = heapClassInst.heapFloat[r3 + numDefine2];
                            f1 = heapClassInst.heapFloat[r1 + numDefine77];
                            r8 = (r4 + 1) | 0;
                            f2 = heapClassInst.heapFloat[r3 + numDefine5];
                            f4 = heapClassInst.heapFloat[r3 + numDefine6];
                            r9 = r4 << numDefine2;
                            f5 = f3 * f0;
                            f7 = f1 * f6;
                            f8 = heapClassInst.heapFloat[r3 + numDefine3];
                            f9 = heapClassInst.heapFloat[r1 + numDefine81];
                            f10 = heapClassInst.heapFloat[r1 + numDefine74];
                            f11 = heapClassInst.heapFloat[r3 + numDefine9];
                            f12 = heapClassInst.heapFloat[r1 + numDefine78];
                            f13 = heapClassInst.heapFloat[r3 + numDefine10];
                            r10 = (r4 + numDefine2) | 0;
                            r8 = r8 << numDefine2;
                            r11 = (r6 + r9) | 0;
                            f14 = heapClassInst.heapFloat[r3 + numDefine11];
                            f15 = heapClassInst.heapFloat[r1 + numDefine82];
                            f16 = heapClassInst.heapFloat[r3 + numDefine7];
                            f17 = f3 * f2;
                            f18 = f1 * f4;
                            f5 = f5 + f7;
                            f7 = f9 * f8;
                            r2 = (r2 + r4) | 0;
                            r3 = r10 << numDefine2;
                            r4 = (r6 + r8) | 0;
                            f5 = f5 + f7;
                            f3 = f3 * f11;
                            f1 = f1 * f13;
                            f7 = f17 + f18;
                            f17 = f9 * f16;
                            r10 = r11 >> numDefine2;
                            r11 = (r2 + 1) | 0;
                            r12 = r2 << numDefine2;
                            r13 = (r6 + r3) | 0;
                            f7 = f7 + f17;
                            f0 = f10 * f0;
                            f6 = f12 * f6;
                            f3 = f3 + f1;
                            f1 = f9 * f14;
                            r4 = r4 >> numDefine2;
                            heapClassInst.heapFloat[r10] = f5;
                            r10 = (r2 + numDefine2) | 0;
                            r11 = r11 << numDefine2;
                            r14 = (r6 + r12) | 0;
                            f3 = f3 + f1;
                            f1 = f10 * f2;
                            f2 = f12 * f4;
                            f0 = f0 + f6;
                            f6 = f15 * f8;
                            r13 = r13 >> numDefine2;
                            heapClassInst.heapFloat[r4] = f7;
                            r4 = r10 << numDefine2;
                            r10 = (r6 + r11) | 0;
                            f0 = f0 + f6;
                            f6 = f10 * f11;
                            f4 = f12 * f13;
                            f1 = f1 + f2;
                            f2 = f15 * f16;
                            r14 = r14 >> numDefine2;
                            heapClassInst.heapFloat[r13] = f3;
                            r6 = (r6 + r4) | 0;
                            f1 = f1 + f2;
                            f6 = f6 + f4;
                            f2 = f15 * f14;
                            r10 = r10 >> numDefine2;
                            heapClassInst.heapFloat[r14] = f0;
                            r13 = (r7 + r9) | 0;
                            f6 = f6 + f2;
                            r6 = r6 >> numDefine2;
                            heapClassInst.heapFloat[r10] = f1;
                            r8 = (r7 + r8) | 0;
                            r10 = r13 >> numDefine2;
                            f2 = -f5;
                            heapClassInst.heapFloat[r6] = f6;
                            r3 = (r7 + r3) | 0;
                            r6 = r8 >> numDefine2;
                            f4 = -f7;
                            heapClassInst.heapFloat[r10] = f2;
                            r8 = (r7 + r12) | 0;
                            r3 = r3 >> numDefine2;
                            f2 = -f3;
                            heapClassInst.heapFloat[r6] = f4;
                            r6 = (r7 + r11) | 0;
                            r8 = r8 >> numDefine2;
                            f4 = -f0;
                            heapClassInst.heapFloat[r3] = f2;
                            r3 = (r7 + r4) | 0;
                            r4 = r6 >> numDefine2;
                            f2 = -f1;
                            heapClassInst.heapFloat[r8] = f4;
                            r3 = r3 >> numDefine2;
                            f4 = -f6;
                            heapClassInst.heapFloat[r4] = f2;
                            heapClassInst.heapFloat[r3] = f4;
                            f2 = heapClassInst.heapFloat[r1 + numDefine112];
                            f4 = heapClassInst.heapFloat[r1 + numDefine113];
                            f8 = heapClassInst.heapFloat[r1 + numDefine114];
                            f2 = f2 * f5;
                            f4 = f4 * f7;
                            r3 = heapClassInst.heap32[r5 + numDefine7];
                            f2 = f2 + f4;
                            f3 = f8 * f3;
                            f4 = heapClassInst.heapFloat[r5];
                            f5 = heapClassInst.heapFloat[r1 + numDefine106];
                            r3 = (r3 + r9) | 0;
                            f3 = f2 + f3;
                            f2 = f4 * f5;
                            r3 = r3 >> numDefine2;
                            f3 = f3 * f2;
                            heapClassInst.heapFloat[r3] = f3;
                            f3 = heapClassInst.heapFloat[r1 + numDefine112];
                            f4 = heapClassInst.heapFloat[r1 + numDefine113];
                            f5 = heapClassInst.heapFloat[r1 + numDefine114];
                            f0 = f3 * f0;
                            f3 = f4 * f1;
                            r3 = heapClassInst.heap32[r5 + numDefine7];
                            f0 = f0 + f3;
                            f3 = f5 * f6;
                            r3 = (r3 + r12) | 0;
                            f0 = f0 + f3;
                            r3 = r3 >> numDefine2;
                            f0 = f0 * f2;
                            heapClassInst.heapFloat[r3] = f0;
                            r3 = heapClassInst.heap32[r5 + numDefine9];
                            r3 = (r3 + r9) | 0;
                            r3 = r3 >> numDefine2;
                            heapClassInst.heap32[r3] = numDefineNeg88609;
                            r3 = heapClassInst.heap32[r5 + numDefine10];
                            r3 = (r3 + r9) | 0;
                            r3 = r3 >> numDefine2;
                            heapClassInst.heap32[r3] = numDefine95039;
                            r3 = heapClassInst.heap32[r5 + numDefine9];
                            r3 = (r3 + r12) | 0;
                            r3 = r3 >> numDefine2;
                            heapClassInst.heap32[r3] = numDefineNeg88609;
                            r3 = heapClassInst.heap32[r5 + numDefine10];
                            r3 = (r3 + r12) | 0;
                            r3 = r3 >> numDefine2;
                            heapClassInst.heap32[r3] = numDefine95039;
                            r3 = heapClassInst.heap32[r5 + numDefine6];
                            r4 = (r3 + r2) | 0;
                            break repeat16;
                        }
                    }
                    r2 = (r4 + 1) | 0;
                    r3 = r4 << numDefine2;
                    f0 = heapClassInst.heapFloat[r1 + numDefine106];
                    f3 = heapClassInst.heapFloat[r1 + numDefine112];
                    r8 = (r4 + numDefine2) | 0;
                    r2 = r2 << numDefine2;
                    r9 = (r6 + r3) | 0;
                    f3 = f3 * f0;
                    f6 = heapClassInst.heapFloat[r1 + numDefine114];
                    f1 = heapClassInst.heapFloat[r1 + numDefine113];
                    r8 = r8 << numDefine2;
                    r10 = (r6 + r2) | 0;
                    f1 = f1 * f0;
                    f3 = f3 * f0;
                    r9 = r9 >> numDefine2;
                    r6 = (r6 + r8) | 0;
                    f6 = f6 * f0;
                    f1 = f1 * f0;
                    r10 = r10 >> numDefine2;
                    heapClassInst.heapFloat[r9] = f3;
                    r9 = (r7 + r3) | 0;
                    f0 = f6 * f0;
                    r6 = r6 >> numDefine2;
                    heapClassInst.heapFloat[r10] = f1;
                    r2 = (r7 + r2) | 0;
                    r9 = r9 >> numDefine2;
                    f3 = -f3;
                    heapClassInst.heapFloat[r6] = f0;
                    r6 = (r7 + r8) | 0;
                    r2 = r2 >> numDefine2;
                    f6 = -f1;
                    heapClassInst.heapFloat[r9] = f3;
                    r6 = r6 >> numDefine2;
                    f0 = -f0;
                    heapClassInst.heapFloat[r2] = f6;
                    heapClassInst.heapFloat[r6] = f0;
                    r2 = heapClassInst.heap32[r5 + numDefine7];
                    f0 = heapClassInst.heapFloat[r5];
                    f3 = heapClassInst.heapFloat[r1 + numDefine105];
                    r2 = (r2 + r3) | 0;
                    f6 = heapClassInst.heapFloat[r1 + numDefine123];
                    f0 = f0 * f3;
                    r2 = r2 >> numDefine2;
                    f0 = f6 * f0;
                    heapClassInst.heapFloat[r2] = f0;
                    r2 = heapClassInst.heapU8[r0 + numDefine580];
                    r2 = r2 & numDefine4;
                    if (!(r2 == 0)) {
                        r2 = heapClassInst.heap32[r5 + numDefine8];
                        r2 = (r2 + r3) | 0;
                        r2 = r2 >> numDefine2;
                        heapClassInst.heap32[r2] = heapClassInst.heap32[r1 + numDefine148];
                    }
                    r2 = heapClassInst.heap32[r5 + numDefine9];
                    r2 = (r2 + r3) | 0;
                    r2 = r2 >> numDefine2;
                    heapClassInst.heap32[r2] = 0;
                    r2 = heapClassInst.heap32[r5 + numDefine10];
                    r2 = (r2 + r3) | 0;
                    r2 = r2 >> numDefine2;
                    heapClassInst.heap32[r2] = numDefine95039;
                    r2 = heapClassInst.heap32[r5 + numDefine6];
                    r4 = (r2 + r4) | 0;
                }
            } while (false);
            r2 = heapClassInst.heapU8[r0 + numDefine513];
            if (r2 == 0) {
                return;
            } else {
                r2 = (r4 + 1) | 0;
                r3 = r4 << numDefine2;
                r6 = heapClassInst.heap32[r5 + numDefine3];
                f0 = heapClassInst.heapFloat[r1 + numDefine106];
                f3 = heapClassInst.heapFloat[r1 + numDefine116];
                r4 = (r4 + numDefine2) | 0;
                r2 = r2 << numDefine2;
                r7 = heapClassInst.heap32[r5 + numDefine5];
                r8 = (r6 + r3) | 0;
                f3 = f3 * f0;
                f6 = heapClassInst.heapFloat[r1 + numDefine118];
                f1 = heapClassInst.heapFloat[r1 + numDefine117];
                r4 = r4 << numDefine2;
                r9 = (r6 + r2) | 0;
                f1 = f1 * f0;
                f3 = f3 * f0;
                r8 = r8 >> numDefine2;
                r6 = (r6 + r4) | 0;
                f6 = f6 * f0;
                f1 = f1 * f0;
                r9 = r9 >> numDefine2;
                heapClassInst.heapFloat[r8] = f3;
                r8 = (r7 + r3) | 0;
                f0 = f6 * f0;
                r6 = r6 >> numDefine2;
                heapClassInst.heapFloat[r9] = f1;
                r2 = (r7 + r2) | 0;
                r8 = r8 >> numDefine2;
                f3 = -f3;
                heapClassInst.heapFloat[r6] = f0;
                r4 = (r7 + r4) | 0;
                r2 = r2 >> numDefine2;
                f6 = -f1;
                heapClassInst.heapFloat[r8] = f3;
                r4 = r4 >> numDefine2;
                f0 = -f0;
                heapClassInst.heapFloat[r2] = f6;
                heapClassInst.heapFloat[r4] = f0;
                r2 = heapClassInst.heap32[r5 + numDefine7];
                f0 = heapClassInst.heapFloat[r5];
                f3 = heapClassInst.heapFloat[r1 + numDefine105];
                r2 = (r2 + r3) | 0;
                f6 = heapClassInst.heapFloat[r1 + numDefine124];
                f0 = f0 * f3;
                r2 = r2 >> numDefine2;
                f0 = f6 * f0;
                heapClassInst.heapFloat[r2] = f0;
                r0 = heapClassInst.heapU8[r0 + numDefine580];
                r0 = r0 & numDefine4;
                if (!(r0 == 0)) {
                    r0 = heapClassInst.heap32[r5 + numDefine8];
                    r0 = (r0 + r3) | 0;
                    r0 = r0 >> numDefine2;
                    heapClassInst.heap32[r0] = heapClassInst.heap32[r1 + numDefine148];
                }
                f0 = heapClassInst.heapFloat[r1 + numDefine110];
                f3 = 0;
                if (f0 <= f3) {
                    r0 = heapClassInst.heap32[r5 + numDefine9];
                    r0 = (r0 + r3) | 0;
                    r0 = r0 >> numDefine2;
                    heapClassInst.heap32[r0] = numDefineNeg88609;
                } else {
                    r0 = heapClassInst.heap32[r5 + numDefine9];
                    f0 = heapClassInst.heapFloat[r1 + numDefine124];
                    if (f0 <= f3) {
                        r0 = (r0 + r3) | 0;
                        r0 = r0 >> numDefine2;
                        heapClassInst.heap32[r0] = numDefineNeg88609;
                        r0 = heapClassInst.heap32[r5 + numDefine10];
                        r3 = (r0 + r3) | 0;
                        r3 = r3 >> numDefine2;
                        heapClassInst.heap32[r3] = 0;
                        return;
                    } else {
                        r0 = (r0 + r3) | 0;
                        r0 = r0 >> numDefine2;
                        heapClassInst.heap32[r0] = 0;
                    }
                }
                r0 = heapClassInst.heap32[r5 + numDefine10];
                r0 = (r0 + r3) | 0;
                r0 = r0 >> numDefine2;
                heapClassInst.heap32[r0] = numDefine95039;
                return;
            }
        } else {
            r0 = twoEStr1149;
            r1 = twoEStr24;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine126;
            assertNew(i7);
        }
    }

    public static void zn21btConeTwistConstraint23solveConstraintObsoleteER11btRigidBodyS1F(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        float f30 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg624;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heapU8[r0 + numDefine515];
        if (!(r1 == 0)) {
            r1 = heapClassInst.heap32[fp + 1];
            r2 = heapClassInst.heap32[fp + numDefine2];
            f0 = heapClassInst.heapFloat[fp + numDefine3];
            heapClassInst.heapFloat[fp + numDefineNeg117] = f0;
            r3 = r0 >> numDefine2;
            r4 = heapClassInst.heapU8[r0 + numDefine512];
            if (!(r4 != 0)) {
                r4 = heapClassInst.heap32[r3 + numDefine5];
                r5 = heapClassInst.heap32[r3 + numDefine6];
                r4 = r4 >> numDefine2;
                r5 = r5 >> numDefine2;
                f0 = heapClassInst.heapFloat[r4 + numDefine9];
                f1 = heapClassInst.heapFloat[r3 + numDefine84];
                f2 = heapClassInst.heapFloat[r4 + numDefine5];
                f3 = heapClassInst.heapFloat[r4 + 1];
                f4 = heapClassInst.heapFloat[r4 + numDefine10];
                f5 = heapClassInst.heapFloat[r3 + numDefine85];
                f6 = heapClassInst.heapFloat[r4 + numDefine6];
                f7 = heapClassInst.heapFloat[r4 + numDefine2];
                f8 = heapClassInst.heapFloat[r5 + numDefine9];
                f9 = heapClassInst.heapFloat[r3 + numDefine100];
                f10 = heapClassInst.heapFloat[r5 + numDefine5];
                f11 = heapClassInst.heapFloat[r5 + 1];
                f12 = heapClassInst.heapFloat[r5 + numDefine10];
                f13 = heapClassInst.heapFloat[r3 + numDefine101];
                f14 = heapClassInst.heapFloat[r5 + numDefine6];
                f15 = heapClassInst.heapFloat[r5 + numDefine2];
                f0 = f0 * f1;
                f4 = f4 * f5;
                f16 = heapClassInst.heapFloat[r4 + numDefine11];
                f17 = heapClassInst.heapFloat[r3 + numDefine86];
                f18 = heapClassInst.heapFloat[r4 + numDefine7];
                f19 = heapClassInst.heapFloat[r4 + numDefine3];
                f2 = f2 * f1;
                f6 = f6 * f5;
                f1 = f3 * f1;
                f3 = f7 * f5;
                f5 = f8 * f9;
                f7 = f12 * f13;
                f8 = heapClassInst.heapFloat[r5 + numDefine11];
                f12 = heapClassInst.heapFloat[r3 + numDefine102];
                f20 = heapClassInst.heapFloat[r5 + numDefine7];
                f21 = heapClassInst.heapFloat[r5 + numDefine3];
                f10 = f10 * f9;
                f14 = f14 * f13;
                f9 = f11 * f9;
                f11 = f15 * f13;
                f0 = f0 + f4;
                f4 = f16 * f17;
                f2 = f2 + f6;
                f6 = f18 * f17;
                f1 = f1 + f3;
                f3 = f19 * f17;
                f5 = f5 + f7;
                f7 = f8 * f12;
                f8 = f10 + f14;
                f10 = f20 * f12;
                f9 = f9 + f11;
                f11 = f21 * f12;
                f12 = heapClassInst.heapFloat[r4 + numDefine15];
                f0 = f0 + f4;
                f4 = heapClassInst.heapFloat[r4 + numDefine14];
                f2 = f2 + f6;
                f6 = heapClassInst.heapFloat[r4 + numDefine13];
                f1 = f1 + f3;
                f3 = heapClassInst.heapFloat[r5 + numDefine15];
                f5 = f5 + f7;
                f7 = heapClassInst.heapFloat[r5 + numDefine14];
                f8 = f8 + f10;
                f10 = heapClassInst.heapFloat[r5 + numDefine13];
                f9 = f9 + f11;
                f0 = f0 + f12;
                heapClassInst.heapFloat[fp + numDefineNeg119] = f0;
                f0 = f2 + f4;
                heapClassInst.heapFloat[fp + numDefineNeg121] = f0;
                f1 = f1 + f6;
                heapClassInst.heapFloat[fp + numDefineNeg120] = f1;
                f0 = f5 + f3;
                heapClassInst.heapFloat[fp + numDefineNeg122] = f0;
                f0 = f8 + f7;
                heapClassInst.heapFloat[fp + numDefineNeg123] = f0;
                f1 = f9 + f10;
                r4 = r1 >> numDefine2;
                r5 = r2 >> numDefine2;
                f2 = heapClassInst.heapFloat[r4 + numDefine80];
                f5 = heapClassInst.heapFloat[r4 + numDefine130];
                f8 = heapClassInst.heapFloat[r5 + numDefine80];
                f9 = heapClassInst.heapFloat[r5 + numDefine130];
                f11 = heapClassInst.heapFloat[r4 + numDefine81];
                f13 = heapClassInst.heapFloat[r4 + numDefine131];
                f14 = heapClassInst.heapFloat[r4 + numDefine82];
                f15 = heapClassInst.heapFloat[r4 + numDefine132];
                f16 = heapClassInst.heapFloat[r5 + numDefine81];
                f17 = heapClassInst.heapFloat[r5 + numDefine131];
                f18 = heapClassInst.heapFloat[r5 + numDefine82];
                f19 = heapClassInst.heapFloat[r5 + numDefine132];
                f20 = heapClassInst.heapFloat[fp + numDefineNeg120];
                f6 = f20 - f6;
                f10 = f1 - f10;
                f11 = f11 + f13;
                f0 = heapClassInst.heapFloat[fp + numDefineNeg119];
                f12 = f0 - f12;
                f2 = f2 + f5;
                f0 = heapClassInst.heapFloat[fp + numDefineNeg121];
                f4 = f0 - f4;
                f5 = f14 + f15;
                f13 = f16 + f17;
                f0 = heapClassInst.heapFloat[fp + numDefineNeg122];
                f3 = f0 - f3;
                f8 = f8 + f9;
                f0 = heapClassInst.heapFloat[fp + numDefineNeg123];
                f7 = f0 - f7;
                f9 = f18 + f19;
                f14 = (int) heapClassInst.heapFloat[r4 + numDefine78];
                f15 = heapClassInst.heapFloat[r4 + numDefine128];
                f16 = f2 * f4;
                f17 = f11 * f6;
                f18 = heapClassInst.heapFloat[r5 + numDefine78];
                f19 = heapClassInst.heapFloat[r5 + numDefine128];
                f21 = f8 * f7;
                f22 = f13 * f10;
                f23 = heapClassInst.heapFloat[r4 + numDefine77];
                f24 = heapClassInst.heapFloat[r4 + numDefine127];
                f25 = f5 * f6;
                f2 = f2 * f12;
                f26 = heapClassInst.heapFloat[r5 + numDefine77];
                f27 = heapClassInst.heapFloat[r5 + numDefine127];
                f28 = f9 * f10;
                f8 = f8 * f3;
                f29 = heapClassInst.heapFloat[r4 + numDefine76];
                f30 = heapClassInst.heapFloat[r4 + numDefine126];
                f11 = f11 * f12;
                f5 = f5 * f4;
                f0 = heapClassInst.heapFloat[r5 + numDefine76];
                f20 = heapClassInst.heapFloat[r5 + numDefine126];
                f13 = f13 * f3;
                f9 = f9 * f7;
                f14 = f14 + f15;
                f15 = f16 - f17;
                f16 = f18 + f19;
                f17 = f21 - f22;
                f18 = f23 + f24;
                f2 = f25 - f2;
                f19 = f26 + f27;
                f8 = f28 - f8;
                f21 = f29 + f30;
                f5 = f11 - f5;
                f0 = f0 + f20;
                f9 = f13 - f9;
                f11 = f14 + f15;
                f13 = f16 + f17;
                f2 = f18 + f2;
                f8 = f19 + f8;
                f5 = f21 + f5;
                f0 = f0 + f9;
                f9 = f11 - f13;
                f2 = f2 - f8;
                heapClassInst.heapFloat[fp + numDefineNeg118] = f2;
                f0 = f5 - f0;
                f2 = heapClassInst.heapFloat[fp + numDefineNeg119];
                f5 = heapClassInst.heapFloat[fp + numDefineNeg122];
                f2 = f2 - f5;
                f5 = heapClassInst.heapFloat[fp + numDefineNeg121];
                f8 = heapClassInst.heapFloat[fp + numDefineNeg123];
                f5 = f5 - f8;
                f8 = heapClassInst.heapFloat[fp + numDefineNeg120];
                f1 = f8 - f1;
                r6 = 0;
                repeat5: while (true) {
                    r7 = (r6 * numDefineNeg21) | 0;
                    r8 = r7 << numDefine2;
                    r8 = (r0 + r8) | 0;
                    r8 = r8 >> numDefine2;
                    f8 = heapClassInst.heapFloat[r8 + numDefine9];
                    f11 = heapClassInst.heapFloat[r8 + numDefine10];
                    f13 = heapClassInst.heapFloat[r8 + numDefine11];
                    f14 = f1 * f8;
                    f15 = f5 * f11;
                    f14 = f14 + f15;
                    f15 = f2 * f13;
                    f14 = f14 + f15;
                    f15 = (float) numDefineNegFloat396;
                    f16 = f8 * f0;
                    f17 = heapClassInst.heapFloat[fp + numDefineNeg118];
                    f17 = f11 * f17;
                    f14 = f14 * f15;
                    f15 = f16 + f17;
                    f16 = f13 * f9;
                    f17 = 1;
                    f18 = heapClassInst.heapFloat[r8 + numDefine29];
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg117];
                    f14 = f14 / f19;
                    f17 = f17 / f18;
                    f15 = f15 + f16;
                    f14 = f14 * f17;
                    f15 = f15 * f17;
                    f14 = f14 - f15;
                    f15 = heapClassInst.heapFloat[r3 + numDefine7];
                    f15 = f15 + f14;
                    heapClassInst.heapFloat[r3 + numDefine7] = f15;
                    f15 = heapClassInst.heapFloat[r4 + numDefine84];
                    f16 = 0;
                    if (!(f15 == f16)) {
                        r9 = heapClassInst.heap32[r3 + numDefine5];
                        r9 = r9 >> numDefine2;
                        f15 = f6 * f11;
                        f17 = f4 * f8;
                        f18 = f12 * f8;
                        f19 = f6 * f13;
                        f20 = f4 * f13;
                        f21 = f12 * f11;
                        f15 = f15 - f17;
                        f17 = f18 - f19;
                        f18 = f20 - f21;
                        f19 = heapClassInst.heapFloat[r9 + numDefine84];
                        f20 = f8 * f19;
                        f20 = f20 * f14;
                        f21 = heapClassInst.heapFloat[r4 + numDefine126];
                        f22 = heapClassInst.heapFloat[r9 + numDefine65];
                        f23 = heapClassInst.heapFloat[r9 + numDefine64];
                        f24 = heapClassInst.heapFloat[r9 + numDefine69];
                        f25 = heapClassInst.heapFloat[r9 + numDefine68];
                        f26 = heapClassInst.heapFloat[r9 + numDefine73];
                        f27 = heapClassInst.heapFloat[r9 + numDefine72];
                        f28 = heapClassInst.heapFloat[r9 + numDefine66];
                        f29 = heapClassInst.heapFloat[r9 + numDefine70];
                        f30 = heapClassInst.heapFloat[r9 + numDefine74];
                        f20 = f21 + f20;
                        f21 = f11 * f19;
                        heapClassInst.heapFloat[r4 + numDefine126] = f20;
                        f20 = f21 * f14;
                        f21 = heapClassInst.heapFloat[r4 + numDefine127];
                        f20 = f21 + f20;
                        f19 = f13 * f19;
                        heapClassInst.heapFloat[r4 + numDefine127] = f20;
                        f19 = f19 * f14;
                        f20 = heapClassInst.heapFloat[r4 + numDefine128];
                        f19 = f20 + f19;
                        heapClassInst.heapFloat[r4 + numDefine128] = f19;
                        f19 = f23 * f18;
                        f20 = f22 * f17;
                        f21 = heapClassInst.heapFloat[r4 + numDefine134];
                        f19 = f19 + f20;
                        f20 = f28 * f15;
                        f19 = f19 + f20;
                        f20 = f21 * f14;
                        f21 = heapClassInst.heapFloat[r4 + numDefine136];
                        f22 = heapClassInst.heapFloat[r4 + numDefine135];
                        f23 = heapClassInst.heapFloat[r4 + numDefine130];
                        f19 = f19 * f20;
                        f20 = f25 * f18;
                        f24 = f24 * f17;
                        f20 = f20 + f24;
                        f24 = f29 * f15;
                        f19 = f23 + f19;
                        heapClassInst.heapFloat[r4 + numDefine130] = f19;
                        f19 = f20 + f24;
                        f20 = f22 * f14;
                        f18 = f27 * f18;
                        f17 = f26 * f17;
                        f19 = f19 * f20;
                        f20 = heapClassInst.heapFloat[r4 + numDefine131];
                        f19 = f20 + f19;
                        f17 = f18 + f17;
                        f15 = f30 * f15;
                        heapClassInst.heapFloat[r4 + numDefine131] = f19;
                        f15 = f17 + f15;
                        f17 = f21 * f14;
                        f15 = f15 * f17;
                        f17 = heapClassInst.heapFloat[r4 + numDefine132];
                        f15 = f17 + f15;
                        heapClassInst.heapFloat[r4 + numDefine132] = f15;
                    }
                    f15 = heapClassInst.heapFloat[r5 + numDefine84];
                    if (!(f15 == f16)) {
                        f15 = f10 * f11;
                        f16 = f7 * f8;
                        f8 = f3 * f8;
                        f17 = f10 * f13;
                        f13 = f7 * f13;
                        f11 = f3 * f11;
                        f15 = f15 - f16;
                        f8 = f8 - f17;
                        f11 = f13 - f11;
                        r9 = heapClassInst.heap32[r3 + numDefine6];
                        r9 = r9 >> numDefine2;
                        f13 = -f14;
                        f14 = heapClassInst.heapFloat[r9 + numDefine84];
                        r10 = r7 << numDefine2;
                        r10 = (r0 + r10) | 0;
                        r10 = r10 >> numDefine2;
                        r7 = r7 << numDefine2;
                        r7 = (r0 + r7) | 0;
                        f16 = heapClassInst.heapFloat[r10 + numDefine9];
                        r7 = r7 >> numDefine2;
                        f16 = f16 * f14;
                        f17 = heapClassInst.heapFloat[r7 + numDefine10];
                        f18 = heapClassInst.heapFloat[r8 + numDefine11];
                        f16 = f16 * f13;
                        f19 = heapClassInst.heapFloat[r5 + numDefine126];
                        f20 = heapClassInst.heapFloat[r9 + numDefine65];
                        f21 = heapClassInst.heapFloat[r9 + numDefine64];
                        f22 = heapClassInst.heapFloat[r9 + numDefine69];
                        f23 = heapClassInst.heapFloat[r9 + numDefine68];
                        f24 = heapClassInst.heapFloat[r9 + numDefine73];
                        f25 = heapClassInst.heapFloat[r9 + numDefine72];
                        f26 = heapClassInst.heapFloat[r9 + numDefine66];
                        f27 = heapClassInst.heapFloat[r9 + numDefine70];
                        f28 = heapClassInst.heapFloat[r9 + numDefine74];
                        f16 = f19 + f16;
                        f17 = f17 * f14;
                        heapClassInst.heapFloat[r5 + numDefine126] = f16;
                        f16 = f17 * f13;
                        f17 = heapClassInst.heapFloat[r5 + numDefine127];
                        f16 = f17 + f16;
                        f14 = f18 * f14;
                        heapClassInst.heapFloat[r5 + numDefine127] = f16;
                        f14 = f14 * f13;
                        f16 = heapClassInst.heapFloat[r5 + numDefine128];
                        f14 = f16 + f14;
                        heapClassInst.heapFloat[r5 + numDefine128] = f14;
                        f14 = f21 * f11;
                        f16 = f20 * f8;
                        f17 = heapClassInst.heapFloat[r5 + numDefine134];
                        f14 = f14 + f16;
                        f16 = f26 * f15;
                        f14 = f14 + f16;
                        f16 = f17 * f13;
                        f17 = heapClassInst.heapFloat[r5 + numDefine136];
                        f18 = heapClassInst.heapFloat[r5 + numDefine135];
                        f19 = heapClassInst.heapFloat[r5 + numDefine130];
                        f14 = f14 * f16;
                        f16 = f23 * f11;
                        f20 = f22 * f8;
                        f16 = f16 + f20;
                        f20 = f27 * f15;
                        f14 = f19 + f14;
                        heapClassInst.heapFloat[r5 + numDefine130] = f14;
                        f14 = f16 + f20;
                        f16 = f18 * f13;
                        f11 = f25 * f11;
                        f8 = f24 * f8;
                        f14 = f14 * f16;
                        f16 = heapClassInst.heapFloat[r5 + numDefine131];
                        f14 = f16 + f14;
                        f8 = f11 + f8;
                        f11 = f28 * f15;
                        heapClassInst.heapFloat[r5 + numDefine131] = f14;
                        f8 = f8 + f11;
                        f11 = f17 * f13;
                        f8 = f8 * f11;
                        f11 = heapClassInst.heapFloat[r5 + numDefine132];
                        f8 = f11 + f8;
                        heapClassInst.heapFloat[r5 + numDefine132] = f8;
                    }
                    r6 = (r6 + -1) | 0;
                    if (!(r6 != numDefineNeg3)) {
                        break repeat5;
                    }
                }
            }
            r4 = heapClassInst.heapU8[r0 + numDefine540];
            repeat14: do {
                if (r4 == 0) {
                    f0 = heapClassInst.heapFloat[r3 + numDefine107];
                    f1 = (float) numDefineFloat1257;
                    if (f0 <= f1) {
                        break repeat14;
                    } else {
                        r4 = r2 >> numDefine2;
                        r5 = r1 >> numDefine2;
                        f0 = heapClassInst.heapFloat[r4 + numDefine81];
                        f2 = heapClassInst.heapFloat[r4 + numDefine131];
                        f3 = heapClassInst.heapFloat[r5 + numDefine81];
                        f4 = heapClassInst.heapFloat[r5 + numDefine131];
                        f5 = heapClassInst.heapFloat[r4 + numDefine80];
                        f6 = heapClassInst.heapFloat[r4 + numDefine130];
                        f7 = heapClassInst.heapFloat[r5 + numDefine80];
                        f8 = heapClassInst.heapFloat[r5 + numDefine130];
                        f9 = heapClassInst.heapFloat[r4 + numDefine82];
                        f10 = heapClassInst.heapFloat[r4 + numDefine132];
                        f11 = heapClassInst.heapFloat[r5 + numDefine82];
                        f12 = heapClassInst.heapFloat[r5 + numDefine132];
                        f0 = f0 + f2;
                        f2 = f3 + f4;
                        f3 = f5 + f6;
                        f4 = f7 + f8;
                        f0 = f0 - f2;
                        f2 = f3 - f4;
                        f3 = f9 + f10;
                        f4 = f11 + f12;
                        f3 = f3 - f4;
                        f4 = f2 * f2;
                        f5 = f0 * f0;
                        f4 = f4 + f5;
                        f5 = f3 * f3;
                        f4 = f4 + f5;
                        if (f4 <= f1) {
                            break repeat14;
                        } else {
                            heapClassInst.heapFloat[g0] = f4;
                            sqrtf(i7);
                            r6 = heapClassInst.heap32[r3 + numDefine5];
                            r7 = heapClassInst.heap32[r3 + numDefine6];
                            f4 = 1;
                            r6 = r6 >> numDefine2;
                            r7 = r7 >> numDefine2;
                            f1 = (float) (f4 / commonVariable.fg0);
                            f5 = heapClassInst.heapFloat[r6 + numDefine64];
                            f6 = f2 * f1;
                            f7 = heapClassInst.heapFloat[r6 + numDefine65];
                            f8 = heapClassInst.heapFloat[r7 + numDefine64];
                            f9 = heapClassInst.heapFloat[r7 + numDefine65];
                            f10 = heapClassInst.heapFloat[r6 + numDefine68];
                            f11 = f0 * f1;
                            f12 = heapClassInst.heapFloat[r6 + numDefine69];
                            f13 = heapClassInst.heapFloat[r7 + numDefine68];
                            f14 = heapClassInst.heapFloat[r7 + numDefine69];
                            f15 = heapClassInst.heapFloat[r6 + numDefine66];
                            f16 = heapClassInst.heapFloat[r6 + numDefine70];
                            f17 = heapClassInst.heapFloat[r7 + numDefine66];
                            f18 = heapClassInst.heapFloat[r7 + numDefine70];
                            f5 = f5 * f6;
                            f10 = f10 * f11;
                            f19 = heapClassInst.heapFloat[r6 + numDefine72];
                            f1 = f3 * f1;
                            f20 = heapClassInst.heapFloat[r6 + numDefine73];
                            f21 = heapClassInst.heapFloat[r7 + numDefine72];
                            f22 = heapClassInst.heapFloat[r7 + numDefine73];
                            f7 = f7 * f6;
                            f12 = f12 * f11;
                            f8 = f8 * f6;
                            f13 = f13 * f11;
                            f9 = f9 * f6;
                            f14 = f14 * f11;
                            f23 = heapClassInst.heapFloat[r6 + numDefine74];
                            f24 = heapClassInst.heapFloat[r7 + numDefine74];
                            f5 = f5 + f10;
                            f10 = f19 * f1;
                            f7 = f7 + f12;
                            f12 = f20 * f1;
                            f15 = f15 * f6;
                            f16 = f16 * f11;
                            f8 = f8 + f13;
                            f13 = f21 * f1;
                            f9 = f9 + f14;
                            f14 = f22 * f1;
                            f17 = f17 * f6;
                            f18 = f18 * f11;
                            f5 = f5 + f10;
                            f7 = f7 + f12;
                            f8 = f8 + f13;
                            f9 = f9 + f14;
                            f10 = f15 + f16;
                            f12 = f23 * f1;
                            f13 = f17 + f18;
                            f14 = f24 * f1;
                            f10 = f10 + f12;
                            f12 = f13 + f14;
                            f5 = f6 * f5;
                            f7 = f11 * f7;
                            f6 = f6 * f8;
                            f8 = f11 * f9;
                            f5 = f5 + f7;
                            f7 = f1 * f10;
                            f6 = f6 + f8;
                            f1 = f1 * f12;
                            f5 = f5 + f7;
                            f1 = f6 + f1;
                            f1 = f5 + f1;
                            f5 = heapClassInst.heapFloat[r3 + numDefine107];
                            f1 = f4 / f1;
                            f1 = f5 * f1;
                            f0 = f0 * f1;
                            f2 = f2 * f1;
                            f1 = f3 * f1;
                            f3 = f2 * f2;
                            f5 = f0 * f0;
                            f3 = f3 + f5;
                            f5 = f1 * f1;
                            f3 = f3 + f5;
                            heapClassInst.heapFloat[g0] = f3;
                            sqrtf(i7);
                            f3 = (float) commonVariable.fg0;
                            f4 = f4 / f3;
                            f1 = f1 * f4;
                            f0 = f0 * f4;
                            f2 = f2 * f4;
                            f4 = heapClassInst.heapFloat[r5 + numDefine84];
                            f5 = 0;
                            if (!(f4 == f5)) {
                                r6 = heapClassInst.heap32[r3 + numDefine5];
                                r6 = r6 >> numDefine2;
                                f4 = f3 * f5;
                                f6 = heapClassInst.heapFloat[r5 + numDefine126];
                                f7 = heapClassInst.heapFloat[r6 + numDefine65];
                                f8 = heapClassInst.heapFloat[r6 + numDefine64];
                                f9 = heapClassInst.heapFloat[r6 + numDefine69];
                                f10 = heapClassInst.heapFloat[r6 + numDefine68];
                                f11 = heapClassInst.heapFloat[r6 + numDefine73];
                                f12 = heapClassInst.heapFloat[r6 + numDefine72];
                                f13 = heapClassInst.heapFloat[r6 + numDefine66];
                                f14 = heapClassInst.heapFloat[r6 + numDefine70];
                                f15 = heapClassInst.heapFloat[r6 + numDefine74];
                                f6 = f6 + f4;
                                heapClassInst.heapFloat[r5 + numDefine126] = f6;
                                f6 = heapClassInst.heapFloat[r5 + numDefine127];
                                f6 = f6 + f4;
                                heapClassInst.heapFloat[r5 + numDefine127] = f6;
                                f6 = heapClassInst.heapFloat[r5 + numDefine128];
                                f4 = f6 + f4;
                                heapClassInst.heapFloat[r5 + numDefine128] = f4;
                                f4 = f8 * f2;
                                f6 = f7 * f0;
                                f7 = heapClassInst.heapFloat[r5 + numDefine134];
                                f4 = f4 + f6;
                                f6 = f13 * f1;
                                f4 = f4 + f6;
                                f6 = f7 * f3;
                                f7 = heapClassInst.heapFloat[r5 + numDefine136];
                                f8 = heapClassInst.heapFloat[r5 + numDefine135];
                                f13 = heapClassInst.heapFloat[r5 + numDefine130];
                                f4 = f4 * f6;
                                f6 = f10 * f2;
                                f9 = f9 * f0;
                                f6 = f6 + f9;
                                f9 = f14 * f1;
                                f4 = f13 + f4;
                                heapClassInst.heapFloat[r5 + numDefine130] = f4;
                                f4 = f6 + f9;
                                f6 = f8 * f3;
                                f8 = f12 * f2;
                                f9 = f11 * f0;
                                f4 = f4 * f6;
                                f6 = heapClassInst.heapFloat[r5 + numDefine131];
                                f4 = f6 + f4;
                                f6 = f8 + f9;
                                f8 = f15 * f1;
                                heapClassInst.heapFloat[r5 + numDefine131] = f4;
                                f4 = f6 + f8;
                                f6 = f7 * f3;
                                f4 = f4 * f6;
                                f6 = heapClassInst.heapFloat[r5 + numDefine132];
                                f4 = f6 + f4;
                                heapClassInst.heapFloat[r5 + numDefine132] = f4;
                            }
                            f4 = heapClassInst.heapFloat[r4 + numDefine84];
                            if (f4 == f5) {
                                break repeat14;
                            } else {
                                f4 = -f3;
                                r5 = heapClassInst.heap32[r3 + numDefine6];
                                r5 = r5 >> numDefine2;
                                f5 = -0;
                                f3 = f3 * f5;
                                f5 = heapClassInst.heapFloat[r4 + numDefine126];
                                f6 = heapClassInst.heapFloat[r5 + numDefine65];
                                f7 = heapClassInst.heapFloat[r5 + numDefine64];
                                f8 = heapClassInst.heapFloat[r5 + numDefine69];
                                f9 = heapClassInst.heapFloat[r5 + numDefine68];
                                f10 = heapClassInst.heapFloat[r5 + numDefine73];
                                f11 = heapClassInst.heapFloat[r5 + numDefine72];
                                f12 = heapClassInst.heapFloat[r5 + numDefine66];
                                f13 = heapClassInst.heapFloat[r5 + numDefine70];
                                f14 = heapClassInst.heapFloat[r5 + numDefine74];
                                f5 = f5 + f3;
                                heapClassInst.heapFloat[r4 + numDefine126] = f5;
                                f5 = heapClassInst.heapFloat[r4 + numDefine127];
                                f5 = f5 + f3;
                                heapClassInst.heapFloat[r4 + numDefine127] = f5;
                                f5 = heapClassInst.heapFloat[r4 + numDefine128];
                                f3 = f5 + f3;
                                heapClassInst.heapFloat[r4 + numDefine128] = f3;
                                f3 = f7 * f2;
                                f5 = f6 * f0;
                                f3 = f3 + f5;
                                f5 = f12 * f1;
                                f6 = heapClassInst.heapFloat[r4 + numDefine134];
                                f3 = f3 + f5;
                                f5 = f6 * f4;
                                f6 = heapClassInst.heapFloat[r4 + numDefine136];
                                f7 = heapClassInst.heapFloat[r4 + numDefine135];
                                f12 = heapClassInst.heapFloat[r4 + numDefine130];
                                f3 = f3 * f5;
                                f5 = f9 * f2;
                                f8 = f8 * f0;
                                f5 = f5 + f8;
                                f8 = f13 * f1;
                                f3 = f12 + f3;
                                heapClassInst.heapFloat[r4 + numDefine130] = f3;
                                f3 = f5 + f8;
                                f5 = f7 * f4;
                                f2 = f11 * f2;
                                f0 = f10 * f0;
                                f3 = f3 * f5;
                                f5 = heapClassInst.heapFloat[r4 + numDefine131];
                                f3 = f5 + f3;
                                f0 = f2 + f0;
                                f1 = f14 * f1;
                                heapClassInst.heapFloat[r4 + numDefine131] = f3;
                                f0 = f0 + f1;
                                f1 = f6 * f4;
                                f0 = f0 * f1;
                                f1 = heapClassInst.heapFloat[r4 + numDefine132];
                                f0 = f1 + f0;
                                heapClassInst.heapFloat[r4 + numDefine132] = f0;
                            }
                        }
                    }
                } else {
                    r4 = heapClassInst.heap32[r3 + numDefine5];
                    r5 = sp + numDefineNeg112;
                    r4 = r4 >> numDefine2;
                    r6 = r5 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg28] = heapClassInst.heap32[r4 + 1];
                    heapClassInst.heap32[r6 + 1] = heapClassInst.heap32[r4 + numDefine2];
                    heapClassInst.heap32[r6 + numDefine2] = heapClassInst.heap32[r4 + numDefine2];
                    heapClassInst.heap32[r6 + numDefine3] = heapClassInst.heap32[r4 + numDefine4];
                    heapClassInst.heap32[r6 + numDefine4] = heapClassInst.heap32[r4 + numDefine5];
                    heapClassInst.heap32[r6 + numDefine5] = heapClassInst.heap32[r4 + numDefine6];
                    heapClassInst.heap32[r6 + numDefine6] = heapClassInst.heap32[r4 + numDefine7];
                    heapClassInst.heap32[r6 + numDefine7] = heapClassInst.heap32[r4 + numDefine8];
                    heapClassInst.heap32[r6 + numDefine8] = heapClassInst.heap32[r4 + numDefine9];
                    heapClassInst.heap32[r6 + numDefine9] = heapClassInst.heap32[r4 + numDefine10];
                    heapClassInst.heap32[r6 + numDefine10] = heapClassInst.heap32[r4 + numDefine11];
                    heapClassInst.heap32[r6 + numDefine11] = heapClassInst.heap32[r4 + numDefine12];
                    heapClassInst.heap32[r6 + numDefine12] = heapClassInst.heap32[r4 + numDefine13];
                    heapClassInst.heap32[r6 + numDefine13] = heapClassInst.heap32[r4 + numDefine14];
                    heapClassInst.heap32[r6 + numDefine14] = heapClassInst.heap32[r4 + numDefine15];
                    heapClassInst.heap32[r6 + numDefine15] = heapClassInst.heap32[r4 + numDefine16];
                    r4 = heapClassInst.heap32[r3 + numDefine6];
                    r6 = sp + numDefineNeg176;
                    r4 = r4 >> numDefine2;
                    r7 = r6 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg44] = heapClassInst.heap32[r4 + 1];
                    heapClassInst.heap32[r7 + 1] = heapClassInst.heap32[r4 + numDefine2];
                    heapClassInst.heap32[r7 + numDefine2] = heapClassInst.heap32[r4 + numDefine2];
                    heapClassInst.heap32[r7 + numDefine3] = heapClassInst.heap32[r4 + numDefine4];
                    heapClassInst.heap32[r7 + numDefine4] = heapClassInst.heap32[r4 + numDefine5];
                    heapClassInst.heap32[r7 + numDefine5] = heapClassInst.heap32[r4 + numDefine6];
                    heapClassInst.heap32[r7 + numDefine6] = heapClassInst.heap32[r4 + numDefine7];
                    heapClassInst.heap32[r7 + numDefine7] = heapClassInst.heap32[r4 + numDefine8];
                    heapClassInst.heap32[r7 + numDefine8] = heapClassInst.heap32[r4 + numDefine9];
                    heapClassInst.heap32[r7 + numDefine9] = heapClassInst.heap32[r4 + numDefine10];
                    heapClassInst.heap32[r7 + numDefine10] = heapClassInst.heap32[r4 + numDefine11];
                    heapClassInst.heap32[r7 + numDefine11] = heapClassInst.heap32[r4 + numDefine12];
                    heapClassInst.heap32[r7 + numDefine12] = heapClassInst.heap32[r4 + numDefine13];
                    heapClassInst.heap32[r7 + numDefine13] = heapClassInst.heap32[r4 + numDefine14];
                    heapClassInst.heap32[r7 + numDefine14] = heapClassInst.heap32[r4 + numDefine15];
                    r8 = r1 >> numDefine2;
                    heapClassInst.heap32[r7 + numDefine15] = heapClassInst.heap32[r4 + numDefine16];
                    f0 = heapClassInst.heapFloat[r8 + numDefine82];
                    f1 = heapClassInst.heapFloat[r8 + numDefine132];
                    f2 = heapClassInst.heapFloat[r8 + numDefine81];
                    f3 = heapClassInst.heapFloat[r8 + numDefine131];
                    f4 = heapClassInst.heapFloat[r8 + numDefine80];
                    f5 = heapClassInst.heapFloat[r8 + numDefine130];
                    r4 = sp + numDefineNeg192;
                    f4 = f4 + f5;
                    r7 = r4 >> numDefine2;
                    f2 = f2 + f3;
                    heapClassInst.heapFloat[fp + numDefineNeg48] = f4;
                    f0 = f0 + f1;
                    heapClassInst.heapFloat[r7 + 1] = f2;
                    heapClassInst.heapFloat[r7 + numDefine2] = f0;
                    r9 = r2 >> numDefine2;
                    heapClassInst.heap32[r7 + numDefine3] = 0;
                    f0 = heapClassInst.heapFloat[r9 + numDefine82];
                    f1 = heapClassInst.heapFloat[r9 + numDefine132];
                    f2 = heapClassInst.heapFloat[r9 + numDefine81];
                    f3 = heapClassInst.heapFloat[r9 + numDefine131];
                    f4 = heapClassInst.heapFloat[r9 + numDefine80];
                    f5 = heapClassInst.heapFloat[r9 + numDefine130];
                    r10 = sp + numDefineNeg208;
                    f4 = f4 + f5;
                    f2 = f2 + f3;
                    heapClassInst.heapFloat[fp + numDefineNeg52] = f4;
                    r11 = r10 >> numDefine2;
                    f0 = f0 + f1;
                    heapClassInst.heapFloat[r11 + 1] = f2;
                    heapClassInst.heapFloat[r11 + numDefine2] = f0;
                    r12 = sp + numDefineNeg272;
                    heapClassInst.heap32[r11 + numDefine3] = 0;
                    r13 = r12 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg68] = numDefine53216;
                    heapClassInst.heap32[r13 + 1] = 0;
                    heapClassInst.heap32[r13 + numDefine2] = 0;
                    heapClassInst.heap32[r13 + numDefine3] = 0;
                    heapClassInst.heap32[r13 + numDefine4] = 0;
                    heapClassInst.heap32[r13 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r13 + numDefine6] = 0;
                    heapClassInst.heap32[r13 + numDefine7] = 0;
                    heapClassInst.heap32[r13 + numDefine8] = 0;
                    heapClassInst.heap32[r13 + numDefine9] = 0;
                    heapClassInst.heap32[r13 + numDefine10] = numDefine53216;
                    heapClassInst.heap32[r13 + numDefine11] = 0;
                    heapClassInst.heap32[r13 + numDefine12] = 0;
                    heapClassInst.heap32[r13 + numDefine13] = 0;
                    heapClassInst.heap32[r13 + numDefine14] = 0;
                    heapClassInst.heap32[r13 + numDefine15] = 0;
                    heapClassInst.heap32[g0] = r5;
                    heapClassInst.heap32[g0 + 1] = 0;
                    heapClassInst.heap32[g0 + numDefine2] = 0;
                    heapClassInst.heap32[g0 + numDefine3] = 0;
                    heapClassInst.heap32[g0 + numDefine4] = r4;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg117];
                    heapClassInst.heapFloat[g0 + numDefine5] = f0;
                    heapClassInst.heap32[g0 + numDefine6] = r12;
                    r4 = sp + numDefineNeg336;
                    zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(i7);
                    r12 = r4 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg84] = numDefine53216;
                    heapClassInst.heap32[r12 + 1] = 0;
                    heapClassInst.heap32[r12 + numDefine2] = 0;
                    heapClassInst.heap32[r12 + numDefine3] = 0;
                    heapClassInst.heap32[r12 + numDefine4] = 0;
                    heapClassInst.heap32[r12 + numDefine5] = numDefine53216;
                    heapClassInst.heap32[r12 + numDefine6] = 0;
                    heapClassInst.heap32[r12 + numDefine7] = 0;
                    heapClassInst.heap32[r12 + numDefine8] = 0;
                    heapClassInst.heap32[r12 + numDefine9] = 0;
                    heapClassInst.heap32[r12 + numDefine10] = numDefine53216;
                    heapClassInst.heap32[r12 + numDefine11] = 0;
                    heapClassInst.heap32[r12 + numDefine12] = 0;
                    heapClassInst.heap32[r12 + numDefine13] = 0;
                    heapClassInst.heap32[r12 + numDefine14] = 0;
                    heapClassInst.heap32[r12 + numDefine15] = 0;
                    heapClassInst.heap32[g0] = r6;
                    heapClassInst.heap32[g0 + 1] = 0;
                    heapClassInst.heap32[g0 + numDefine2] = 0;
                    heapClassInst.heap32[g0 + numDefine3] = 0;
                    heapClassInst.heap32[g0 + numDefine4] = r10;
                    heapClassInst.heapFloat[g0 + numDefine5] = f0;
                    heapClassInst.heap32[g0 + numDefine6] = r4;
                    zn15btTransformUtil18integrateTransformERK11btTransformRK9btVector3S5FRS0(i7);
                    f1 = heapClassInst.heapFloat[r3 + numDefine136];
                    f2 = heapClassInst.heapFloat[r3 + numDefine137];
                    f3 = heapClassInst.heapFloat[r3 + numDefine138];
                    f4 = f1 * f1;
                    f5 = f2 * f2;
                    f6 = heapClassInst.heapFloat[r3 + numDefine139];
                    f4 = f4 + f5;
                    f5 = f3 * f3;
                    f4 = f4 + f5;
                    f5 = f6 * f6;
                    f7 = numDefine2;
                    f4 = f4 + f5;
                    f4 = f7 / f4;
                    f5 = f3 * f4;
                    f7 = f2 * f4;
                    f4 = f1 * f4;
                    f3 = f3 * f5;
                    f8 = f1 * f4;
                    f9 = f2 * f7;
                    f0 = 1;
                    heapClassInst.heapFloat[fp + numDefineNeg118] = f0;
                    f10 = f9 + f3;
                    f3 = f8 + f3;
                    f11 = f1 * f7;
                    f12 = f6 * f5;
                    f10 = f0 - f10;
                    f0 = heapClassInst.heapFloat[r3 + numDefine92];
                    heapClassInst.heapFloat[fp + numDefineNeg131] = f0;
                    f13 = f11 - f12;
                    f0 = heapClassInst.heapFloat[r3 + numDefine88];
                    heapClassInst.heapFloat[fp + numDefineNeg120] = f0;
                    f11 = f11 + f12;
                    f12 = heapClassInst.heapFloat[r3 + numDefine93];
                    heapClassInst.heapFloat[fp + numDefineNeg132] = f12;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg118];
                    f3 = f0 - f3;
                    f0 = heapClassInst.heapFloat[r3 + numDefine89];
                    heapClassInst.heapFloat[fp + numDefineNeg121] = f0;
                    f1 = f1 * f5;
                    f7 = f6 * f7;
                    f2 = f2 * f5;
                    f4 = f6 * f4;
                    f5 = f1 + f7;
                    f6 = heapClassInst.heapFloat[r3 + numDefine96];
                    heapClassInst.heapFloat[fp + numDefineNeg129] = f6;
                    f12 = f2 - f4;
                    f14 = heapClassInst.heapFloat[r3 + numDefine97];
                    heapClassInst.heapFloat[fp + numDefineNeg136] = f14;
                    f8 = f8 + f9;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg120];
                    f9 = f10 * f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg121];
                    f15 = f11 * f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg120];
                    f16 = f13 * f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg121];
                    f17 = f3 * f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg131];
                    f18 = f10 * f0;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg132];
                    f20 = f11 * f19;
                    f21 = f13 * f0;
                    f22 = f3 * f19;
                    f1 = f1 - f7;
                    f7 = heapClassInst.heapFloat[r3 + numDefine94];
                    heapClassInst.heapFloat[fp + numDefineNeg137] = f7;
                    f2 = f2 + f4;
                    f0 = heapClassInst.heapFloat[r3 + numDefine90];
                    heapClassInst.heapFloat[fp + numDefineNeg133] = f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg118];
                    f4 = f0 - f8;
                    f6 = heapClassInst.heapFloat[r3 + numDefine98];
                    heapClassInst.heapFloat[fp + numDefineNeg130] = f6;
                    f7 = f9 + f15;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg133];
                    f8 = f1 * f0;
                    f9 = f16 + f17;
                    f14 = f2 * f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg120];
                    f15 = f5 * f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg121];
                    f16 = f12 * f0;
                    f17 = f18 + f20;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg137];
                    f19 = f1 * f18;
                    f20 = f21 + f22;
                    f21 = f2 * f18;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg131];
                    f22 = f5 * f0;
                    f23 = heapClassInst.heapFloat[fp + numDefineNeg132];
                    f24 = f12 * f23;
                    f6 = heapClassInst.heapFloat[fp + numDefineNeg129];
                    f10 = f10 * f6;
                    f25 = heapClassInst.heapFloat[fp + numDefineNeg136];
                    f11 = f11 * f25;
                    f13 = f13 * f6;
                    f3 = f3 * f25;
                    f0 = f7 + f8;
                    heapClassInst.heapFloat[fp + numDefineNeg124] = f0;
                    f6 = heapClassInst.heapFloat[r3 + numDefine72];
                    f7 = f17 + f19;
                    heapClassInst.heapFloat[fp + numDefineNeg134] = f7;
                    f0 = f9 + f14;
                    heapClassInst.heapFloat[fp + numDefineNeg125] = f0;
                    f7 = heapClassInst.heapFloat[r3 + numDefine73];
                    f8 = f20 + f21;
                    heapClassInst.heapFloat[fp + numDefineNeg139] = f8;
                    f9 = f15 + f16;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg133];
                    f14 = f4 * f0;
                    f15 = f22 + f24;
                    f16 = f4 * f18;
                    f10 = f10 + f11;
                    f11 = heapClassInst.heapFloat[fp + numDefineNeg130];
                    f1 = f1 * f11;
                    f3 = f13 + f3;
                    f2 = f2 * f11;
                    f13 = heapClassInst.heapFloat[fp + numDefineNeg129];
                    f5 = f5 * f13;
                    f12 = f12 * f25;
                    f17 = heapClassInst.heapFloat[r3 + numDefine76];
                    f1 = f10 + f1;
                    heapClassInst.heapFloat[fp + numDefineNeg138] = f1;
                    f10 = heapClassInst.heapFloat[r3 + numDefine77];
                    f2 = f3 + f2;
                    heapClassInst.heapFloat[fp + numDefineNeg123] = f2;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg124];
                    f3 = f6 * f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg125];
                    f19 = f7 * f0;
                    f0 = f9 + f14;
                    heapClassInst.heapFloat[fp + numDefineNeg126] = f0;
                    f1 = heapClassInst.heapFloat[r3 + numDefine74];
                    f0 = f15 + f16;
                    heapClassInst.heapFloat[fp + numDefineNeg127] = f0;
                    f2 = heapClassInst.heapFloat[fp + numDefineNeg134];
                    f8 = f6 * f2;
                    f9 = heapClassInst.heapFloat[fp + numDefineNeg139];
                    f11 = f7 * f9;
                    f5 = f5 + f12;
                    f12 = heapClassInst.heapFloat[fp + numDefineNeg130];
                    f4 = f4 * f12;
                    f13 = heapClassInst.heapFloat[r3 + numDefine80];
                    f14 = heapClassInst.heapFloat[r3 + numDefine81];
                    f15 = heapClassInst.heapFloat[r3 + numDefine78];
                    f4 = f5 + f4;
                    heapClassInst.heapFloat[fp + numDefineNeg122] = f4;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg124];
                    f5 = f17 * f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg125];
                    f16 = f10 * f0;
                    f18 = f17 * f2;
                    f20 = f10 * f9;
                    f3 = f3 + f19;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg126];
                    f19 = f1 * f0;
                    f8 = f8 + f11;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg127];
                    f11 = f1 * f0;
                    f21 = heapClassInst.heapFloat[fp + numDefineNeg138];
                    f22 = f6 * f21;
                    f2 = heapClassInst.heapFloat[fp + numDefineNeg123];
                    f23 = f7 * f2;
                    f24 = heapClassInst.heapFloat[r3 + numDefine82];
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg124];
                    f25 = f13 * f0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg125];
                    f26 = f14 * f0;
                    f2 = heapClassInst.heapFloat[fp + numDefineNeg134];
                    f27 = f13 * f2;
                    f28 = f14 * f9;
                    f5 = f5 + f16;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg126];
                    f16 = f15 * f0;
                    f18 = f18 + f20;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg127];
                    f20 = f15 * f0;
                    f29 = f17 * f21;
                    f2 = heapClassInst.heapFloat[fp + numDefineNeg123];
                    f30 = f10 * f2;
                    f3 = f3 + f19;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg84];
                    heapClassInst.heapFloat[fp + numDefineNeg140] = f19;
                    f0 = f8 + f11;
                    heapClassInst.heapFloat[fp + numDefineNeg135] = f0;
                    f2 = heapClassInst.heapFloat[r12 + 1];
                    heapClassInst.heapFloat[fp + numDefineNeg128] = f2;
                    f4 = f22 + f23;
                    f8 = heapClassInst.heapFloat[fp + numDefineNeg122];
                    f9 = f1 * f8;
                    f5 = f5 + f16;
                    f0 = f18 + f20;
                    heapClassInst.heapFloat[fp + numDefineNeg119] = f0;
                    f2 = f25 + f26;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg126];
                    f8 = f24 * f0;
                    f11 = f27 + f28;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg127];
                    f12 = f24 * f0;
                    f16 = f13 * f21;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg123];
                    f19 = f14 * f18;
                    f20 = f29 + f30;
                    f22 = heapClassInst.heapFloat[fp + numDefineNeg122];
                    f23 = f15 * f22;
                    f25 = heapClassInst.heapFloat[fp + numDefineNeg140];
                    f26 = f3 * f25;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg135];
                    f27 = heapClassInst.heapFloat[fp + numDefineNeg128];
                    f28 = f0 * f27;
                    f4 = f4 + f9;
                    f9 = heapClassInst.heapFloat[r12 + numDefine2];
                    f29 = heapClassInst.heapFloat[r3 + numDefine86];
                    f30 = heapClassInst.heapFloat[r3 + numDefine85];
                    f0 = heapClassInst.heapFloat[r12 + numDefine8];
                    heapClassInst.heapFloat[fp + numDefineNeg141] = f0;
                    f2 = f2 + f8;
                    f8 = heapClassInst.heapFloat[r12 + numDefine4];
                    f0 = heapClassInst.heapFloat[r12 + numDefine9];
                    f11 = f11 + f12;
                    f12 = heapClassInst.heapFloat[r12 + numDefine5];
                    f20 = f20 + f23;
                    f18 = heapClassInst.heapFloat[r12 + numDefine10];
                    heapClassInst.heapFloat[fp + numDefineNeg148] = f18;
                    f21 = heapClassInst.heapFloat[r12 + numDefine6];
                    f22 = heapClassInst.heapFloat[r3 + numDefine84];
                    f16 = f16 + f19;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg122];
                    f23 = f24 * f19;
                    f27 = f5 * f25;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg119];
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg128];
                    f18 = f19 * f18;
                    f26 = f26 + f28;
                    f28 = f4 * f9;
                    f19 = heapClassInst.heapFloat[r3 + numDefine102];
                    heapClassInst.heapFloat[fp + numDefineNeg142] = f19;
                    f19 = heapClassInst.heapFloat[r3 + numDefine101];
                    heapClassInst.heapFloat[fp + numDefineNeg143] = f19;
                    f19 = heapClassInst.heapFloat[r3 + numDefine100];
                    heapClassInst.heapFloat[fp + numDefineNeg145] = f19;
                    f19 = heapClassInst.heapFloat[r12 + numDefine14];
                    heapClassInst.heapFloat[fp + numDefineNeg144] = f19;
                    f19 = heapClassInst.heapFloat[r12 + numDefine13];
                    heapClassInst.heapFloat[fp + numDefineNeg146] = f19;
                    f19 = heapClassInst.heapFloat[r12 + numDefine12];
                    heapClassInst.heapFloat[fp + numDefineNeg147] = f19;
                    f16 = f16 + f23;
                    r4 = sp + numDefineNeg400;
                    f23 = f2 * f25;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg128];
                    f19 = f11 * f19;
                    f18 = f27 + f18;
                    f27 = f20 * f9;
                    f26 = f26 + f28;
                    f22 = -f22;
                    r10 = r4 >> numDefine2;
                    f19 = f23 + f19;
                    f23 = f16 * f9;
                    f18 = f18 + f27;
                    heapClassInst.heapFloat[fp + numDefineNeg100] = f26;
                    f6 = f6 * f22;
                    f17 = f17 * f30;
                    f7 = f7 * f22;
                    f10 = f10 * f30;
                    f26 = f3 * f8;
                    f27 = heapClassInst.heapFloat[fp + numDefineNeg135];
                    f28 = f27 * f12;
                    f19 = f19 + f23;
                    heapClassInst.heapFloat[r10 + 1] = f18;
                    f18 = 0;
                    heapClassInst.heapFloat[r10 + numDefine2] = f19;
                    f6 = f6 - f17;
                    f13 = f13 * f29;
                    f7 = f7 - f10;
                    f10 = f14 * f29;
                    f1 = f1 * f22;
                    f14 = f15 * f30;
                    f15 = f5 * f8;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg119];
                    f17 = f19 * f12;
                    f22 = f26 + f28;
                    f23 = f4 * f21;
                    f6 = f6 - f13;
                    f7 = f7 - f10;
                    f10 = heapClassInst.heapFloat[fp + numDefineNeg120];
                    f10 = f10 * f18;
                    f13 = heapClassInst.heapFloat[fp + numDefineNeg121];
                    f13 = f13 * f18;
                    f26 = heapClassInst.heapFloat[fp + numDefineNeg131];
                    f26 = f26 * f18;
                    f28 = heapClassInst.heapFloat[fp + numDefineNeg132];
                    f28 = f28 * f18;
                    f1 = f1 - f14;
                    f14 = f24 * f29;
                    f24 = f2 * f8;
                    f29 = f11 * f12;
                    f15 = f15 + f17;
                    f17 = f20 * f21;
                    f22 = f22 + f23;
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    f1 = f1 - f14;
                    f14 = heapClassInst.heapFloat[fp + numDefineNeg124];
                    f14 = f14 * f6;
                    f23 = heapClassInst.heapFloat[fp + numDefineNeg125];
                    f23 = f23 * f7;
                    f10 = f10 + f13;
                    f13 = heapClassInst.heapFloat[fp + numDefineNeg133];
                    f13 = f13 * f18;
                    f30 = heapClassInst.heapFloat[fp + numDefineNeg134];
                    f30 = f30 * f6;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg139];
                    f19 = f19 * f7;
                    f26 = f26 + f28;
                    f28 = heapClassInst.heapFloat[fp + numDefineNeg137];
                    f28 = f28 * f18;
                    f25 = heapClassInst.heapFloat[fp + numDefineNeg129];
                    f25 = f25 * f18;
                    f27 = heapClassInst.heapFloat[fp + numDefineNeg136];
                    f27 = f27 * f18;
                    f24 = f24 + f29;
                    f29 = f16 * f21;
                    f15 = f15 + f17;
                    heapClassInst.heapFloat[r10 + numDefine4] = f22;
                    f10 = f10 + f13;
                    f13 = f26 + f28;
                    f14 = f14 + f23;
                    f17 = heapClassInst.heapFloat[fp + numDefineNeg126];
                    f17 = f17 * f1;
                    f19 = f30 + f19;
                    f22 = heapClassInst.heapFloat[fp + numDefineNeg127];
                    f22 = f22 * f1;
                    f23 = heapClassInst.heapFloat[fp + numDefineNeg138];
                    f6 = f23 * f6;
                    f23 = heapClassInst.heapFloat[fp + numDefineNeg123];
                    f7 = f23 * f7;
                    f23 = f25 + f27;
                    f25 = heapClassInst.heapFloat[fp + numDefineNeg130];
                    f25 = f25 * f18;
                    f26 = heapClassInst.heapFloat[fp + numDefineNeg141];
                    f27 = f3 * f26;
                    f28 = heapClassInst.heapFloat[fp + numDefineNeg135];
                    f30 = f28 * f0;
                    f24 = f24 + f29;
                    heapClassInst.heapFloat[r10 + numDefine5] = f15;
                    f15 = f23 + f25;
                    heapClassInst.heapFloat[r10 + numDefine6] = f24;
                    f14 = f14 + f17;
                    f17 = heapClassInst.heapFloat[fp + numDefineNeg145];
                    f10 = f10 + f17;
                    f17 = f19 + f22;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg143];
                    f13 = f13 + f19;
                    f6 = f6 + f7;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg122];
                    f1 = f19 * f1;
                    f7 = f5 * f26;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg119];
                    f22 = f19 * f0;
                    f23 = f27 + f30;
                    f24 = heapClassInst.heapFloat[fp + numDefineNeg148];
                    f25 = f4 * f24;
                    f13 = f17 + f13;
                    f10 = f14 + f10;
                    f1 = f6 + f1;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg142];
                    f6 = f15 + f19;
                    f14 = f2 * f26;
                    f15 = f11 * f0;
                    f7 = f7 + f22;
                    f17 = f20 * f24;
                    f19 = f23 + f25;
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    f1 = f1 + f6;
                    f25 = heapClassInst.heapFloat[fp + numDefineNeg140];
                    f6 = f25 * f10;
                    f22 = heapClassInst.heapFloat[fp + numDefineNeg128];
                    f22 = f22 * f13;
                    f14 = f14 + f15;
                    f15 = f16 * f24;
                    f7 = f7 + f17;
                    heapClassInst.heapFloat[r10 + numDefine8] = f19;
                    f8 = f8 * f10;
                    f12 = f12 * f13;
                    f6 = f6 + f22;
                    f9 = f9 * f1;
                    f14 = f14 + f15;
                    heapClassInst.heapFloat[r10 + numDefine9] = f7;
                    f6 = f6 + f9;
                    heapClassInst.heapFloat[r10 + numDefine10] = f14;
                    f7 = f26 * f10;
                    f0 = f0 * f13;
                    f8 = f8 + f12;
                    f9 = f21 * f1;
                    f8 = f8 + f9;
                    f0 = f7 + f0;
                    f7 = f24 * f1;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg147];
                    f6 = f6 + f19;
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    f0 = f0 + f7;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg146];
                    f7 = f8 + f19;
                    heapClassInst.heapFloat[r10 + numDefine12] = f6;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg144];
                    f0 = f0 + f19;
                    heapClassInst.heapFloat[r10 + numDefine13] = f7;
                    heapClassInst.heapFloat[r10 + numDefine14] = f0;
                    heapClassInst.heap32[r10 + numDefine15] = 0;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg68];
                    f6 = heapClassInst.heapFloat[r13 + 1];
                    f7 = heapClassInst.heapFloat[r13 + numDefine2];
                    f8 = f3 * f0;
                    f9 = f5 * f6;
                    f12 = heapClassInst.heapFloat[r13 + numDefine8];
                    f14 = heapClassInst.heapFloat[r13 + numDefine9];
                    f15 = heapClassInst.heapFloat[r13 + numDefine10];
                    f17 = heapClassInst.heapFloat[r13 + numDefine4];
                    f19 = heapClassInst.heapFloat[r13 + numDefine5];
                    f21 = heapClassInst.heapFloat[r13 + numDefine6];
                    f22 = f28 * f0;
                    f23 = heapClassInst.heapFloat[fp + numDefineNeg119];
                    f24 = f23 * f6;
                    f8 = f8 + f9;
                    f9 = f2 * f7;
                    f25 = heapClassInst.heapFloat[r13 + numDefine14];
                    f26 = heapClassInst.heapFloat[r13 + numDefine13];
                    f27 = heapClassInst.heapFloat[r13 + numDefine12];
                    r10 = sp + numDefineNeg464;
                    f29 = f4 * f0;
                    f30 = f20 * f6;
                    f22 = f22 + f24;
                    f24 = f11 * f7;
                    f8 = f8 + f9;
                    r12 = r10 >> numDefine2;
                    f9 = f29 + f30;
                    f29 = f16 * f7;
                    f22 = f22 + f24;
                    heapClassInst.heapFloat[fp + numDefineNeg116] = f8;
                    f8 = f3 * f17;
                    f24 = f5 * f19;
                    f9 = f9 + f29;
                    heapClassInst.heapFloat[r12 + 1] = f22;
                    heapClassInst.heapFloat[r12 + numDefine2] = f9;
                    f9 = f28 * f17;
                    f22 = f23 * f19;
                    f8 = f8 + f24;
                    f24 = f2 * f21;
                    f29 = f4 * f17;
                    f30 = f20 * f19;
                    f9 = f9 + f22;
                    f22 = f11 * f21;
                    f8 = f8 + f24;
                    heapClassInst.heap32[r12 + numDefine3] = 0;
                    f10 = -f10;
                    f24 = f29 + f30;
                    f29 = f16 * f21;
                    f9 = f9 + f22;
                    heapClassInst.heapFloat[r12 + numDefine4] = f8;
                    f8 = f3 * f10;
                    f22 = f28 * f13;
                    f30 = f5 * f10;
                    f23 = f23 * f13;
                    f3 = f3 * f12;
                    f5 = f5 * f14;
                    f24 = f24 + f29;
                    heapClassInst.heapFloat[r12 + numDefine5] = f9;
                    heapClassInst.heapFloat[r12 + numDefine6] = f24;
                    f8 = f8 - f22;
                    f9 = f4 * f1;
                    f22 = f30 - f23;
                    f23 = f20 * f1;
                    f10 = f2 * f10;
                    f13 = f11 * f13;
                    f24 = f28 * f12;
                    f28 = heapClassInst.heapFloat[fp + numDefineNeg119];
                    f28 = f28 * f14;
                    f3 = f3 + f5;
                    f2 = f2 * f15;
                    f5 = f8 - f9;
                    f8 = f22 - f23;
                    f9 = f10 - f13;
                    f1 = f16 * f1;
                    f4 = f4 * f12;
                    f10 = f20 * f14;
                    f13 = f24 + f28;
                    f11 = f11 * f15;
                    f2 = f3 + f2;
                    heapClassInst.heap32[r12 + numDefine7] = 0;
                    f1 = f9 - f1;
                    f0 = f0 * f5;
                    f3 = f6 * f8;
                    f4 = f4 + f10;
                    f6 = f16 * f15;
                    f9 = f13 + f11;
                    heapClassInst.heapFloat[r12 + numDefine8] = f2;
                    f2 = f17 * f5;
                    f10 = f19 * f8;
                    f0 = f0 + f3;
                    f3 = f7 * f1;
                    f4 = f4 + f6;
                    heapClassInst.heapFloat[r12 + numDefine9] = f9;
                    f0 = f0 + f3;
                    heapClassInst.heapFloat[r12 + numDefine10] = f4;
                    f3 = f12 * f5;
                    f4 = f14 * f8;
                    f2 = f2 + f10;
                    f5 = f21 * f1;
                    f2 = f2 + f5;
                    f3 = f3 + f4;
                    f1 = f15 * f1;
                    f0 = f0 + f27;
                    heapClassInst.heap32[r12 + numDefine11] = 0;
                    f1 = f3 + f1;
                    f2 = f2 + f26;
                    heapClassInst.heapFloat[r12 + numDefine12] = f0;
                    f0 = f1 + f25;
                    heapClassInst.heapFloat[r12 + numDefine13] = f2;
                    heapClassInst.heapFloat[r12 + numDefine14] = f0;
                    heapClassInst.heap32[r12 + numDefine15] = 0;
                    r12 = sp + numDefineNeg16;
                    r13 = sp + numDefineNeg20;
                    heapClassInst.heap32[g0] = r5;
                    heapClassInst.heap32[g0 + 1] = r4;
                    heapClassInst.heap32[g0 + numDefine2] = r12;
                    heapClassInst.heap32[g0 + numDefine3] = r13;
                    zn15btTransformUtil22calculateDiffAxisAngleERK11btTransformS2R9btVector3Rf(i7);
                    r4 = r12 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r4 + numDefine2];
                    f1 = heapClassInst.heapFloat[fp + numDefineNeg5];
                    f2 = heapClassInst.heapFloat[r4 + 1];
                    f3 = heapClassInst.heapFloat[fp + numDefineNeg4];
                    r4 = sp + numDefineNeg40;
                    r5 = sp + numDefineNeg44;
                    heapClassInst.heap32[g0] = r6;
                    heapClassInst.heap32[g0 + 1] = r10;
                    heapClassInst.heap32[g0 + numDefine2] = r4;
                    heapClassInst.heap32[g0 + numDefine3] = r5;
                    zn15btTransformUtil22calculateDiffAxisAngleERK11btTransformS2R9btVector3Rf(i7);
                    f2 = f2 * f1;
                    f5 = heapClassInst.heapFloat[fp + numDefineNeg118];
                    f4 = heapClassInst.heapFloat[fp + numDefineNeg117];
                    f4 = f5 / f4;
                    f3 = f3 * f1;
                    r4 = r4 >> numDefine2;
                    f0 = f0 * f1;
                    f1 = f2 * f4;
                    f2 = heapClassInst.heapFloat[r7 + 1];
                    f3 = f3 * f4;
                    f5 = heapClassInst.heapFloat[fp + numDefineNeg48];
                    f1 = f1 - f2;
                    f2 = f3 - f5;
                    f0 = f0 * f4;
                    f3 = heapClassInst.heapFloat[r7 + numDefine2];
                    f5 = heapClassInst.heapFloat[r4 + numDefine2];
                    f6 = heapClassInst.heapFloat[fp + numDefineNeg11];
                    f7 = heapClassInst.heapFloat[r4 + 1];
                    f8 = heapClassInst.heapFloat[fp + numDefineNeg10];
                    f0 = f0 - f3;
                    f3 = f5 * f6;
                    f5 = f7 * f6;
                    f6 = f8 * f6;
                    f7 = f2 * f2;
                    f8 = f1 * f1;
                    f7 = f7 + f8;
                    f8 = f0 * f0;
                    f3 = f3 * f4;
                    f9 = heapClassInst.heapFloat[r11 + numDefine2];
                    f5 = f5 * f4;
                    f10 = heapClassInst.heapFloat[r11 + 1];
                    f4 = f6 * f4;
                    f6 = heapClassInst.heapFloat[fp + numDefineNeg52];
                    f7 = f7 + f8;
                    f3 = f3 - f9;
                    f5 = f5 - f10;
                    f4 = f4 - f6;
                    f6 = (float) numDefineFloat1257;
                    if (f7 > f6) {
                        heapClassInst.heapFloat[g0] = f7;
                        sqrtf(i7);
                        r4 = heapClassInst.heap32[r3 + numDefine5];
                        r4 = r4 >> numDefine2;
                        f7 = heapClassInst.heapFloat[fp + numDefineNeg118];
                        f18 = (float) (f7 / commonVariable.fg0);
                        f7 = f2 * f18;
                        f8 = heapClassInst.heapFloat[r4 + numDefine64];
                        f9 = heapClassInst.heapFloat[r4 + numDefine65];
                        f10 = f1 * f18;
                        f11 = heapClassInst.heapFloat[r4 + numDefine68];
                        f12 = heapClassInst.heapFloat[r4 + numDefine69];
                        f13 = f0 * f18;
                        f18 = heapClassInst.heapFloat[r4 + numDefine72];
                        f14 = heapClassInst.heapFloat[r4 + numDefine73];
                        f15 = heapClassInst.heapFloat[r4 + numDefine66];
                        f16 = heapClassInst.heapFloat[r4 + numDefine70];
                        f8 = f8 * f7;
                        f11 = f11 * f10;
                        f9 = f9 * f7;
                        f12 = f12 * f10;
                        f17 = heapClassInst.heapFloat[r4 + numDefine74];
                        f8 = f8 + f11;
                        f18 = f18 * f13;
                        f9 = f9 + f12;
                        f11 = f14 * f13;
                        f12 = f15 * f7;
                        f14 = f16 * f10;
                        f18 = f8 + f18;
                        f8 = f9 + f11;
                        f9 = f12 + f14;
                        f11 = f17 * f13;
                        f9 = f9 + f11;
                        f18 = f7 * f18;
                        f8 = f10 * f8;
                        f18 = f18 + f8;
                        f8 = f13 * f9;
                        f18 = f18 + f8;
                    }
                    f8 = f4 * f4;
                    f9 = f5 * f5;
                    f8 = f8 + f9;
                    f9 = f3 * f3;
                    f8 = f8 + f9;
                    if (f8 > f6) {
                        heapClassInst.heapFloat[g0] = f8;
                        sqrtf(i7);
                        r4 = heapClassInst.heap32[r3 + numDefine6];
                        r4 = r4 >> numDefine2;
                        f9 = heapClassInst.heapFloat[fp + numDefineNeg118];
                        f8 = (float) (f9 / commonVariable.fg0);
                        f9 = f4 * f8;
                        f11 = heapClassInst.heapFloat[r4 + numDefine64];
                        f12 = heapClassInst.heapFloat[r4 + numDefine65];
                        f14 = f5 * f8;
                        f15 = heapClassInst.heapFloat[r4 + numDefine68];
                        f16 = heapClassInst.heapFloat[r4 + numDefine69];
                        f17 = f3 * f8;
                        f8 = heapClassInst.heapFloat[r4 + numDefine72];
                        f19 = heapClassInst.heapFloat[r4 + numDefine73];
                        f20 = heapClassInst.heapFloat[r4 + numDefine66];
                        f21 = heapClassInst.heapFloat[r4 + numDefine70];
                        f11 = f11 * f9;
                        f15 = f15 * f14;
                        f12 = f12 * f9;
                        f16 = f16 * f14;
                        f22 = heapClassInst.heapFloat[r4 + numDefine74];
                        f11 = f11 + f15;
                        f8 = f8 * f17;
                        f12 = f12 + f16;
                        f15 = f19 * f17;
                        f16 = f20 * f9;
                        f19 = f21 * f14;
                        f8 = f11 + f8;
                        f11 = f12 + f15;
                        f12 = f16 + f19;
                        f15 = f22 * f17;
                        f12 = f12 + f15;
                        f8 = f9 * f8;
                        f11 = f14 * f11;
                        f8 = f8 + f11;
                        f11 = f17 * f12;
                        f8 = f8 + f11;
                    } else {
                        f8 = 0;
                    }
                    f10 = f10 * f18;
                    f11 = f14 * f8;
                    f7 = f7 * f18;
                    f9 = f9 * f8;
                    f10 = f10 + f11;
                    f7 = f7 + f9;
                    f9 = f13 * f18;
                    f8 = f17 * f8;
                    f8 = f9 + f8;
                    f9 = f7 * f7;
                    f11 = f10 * f10;
                    f9 = f9 + f11;
                    f11 = f8 * f8;
                    f9 = f9 + f11;
                    if (!(f9 <= f6)) {
                        heapClassInst.heapFloat[g0] = f9;
                        sqrtf(i7);
                        r4 = heapClassInst.heap32[r3 + numDefine5];
                        r5 = heapClassInst.heap32[r3 + numDefine6];
                        r4 = r4 >> numDefine2;
                        r5 = r5 >> numDefine2;
                        f9 = heapClassInst.heapFloat[fp + numDefineNeg118];
                        f6 = (float) (f9 / commonVariable.fg0);
                        f11 = heapClassInst.heapFloat[r4 + numDefine64];
                        f7 = f7 * f6;
                        f12 = heapClassInst.heapFloat[r4 + numDefine65];
                        f13 = heapClassInst.heapFloat[r5 + numDefine64];
                        f14 = heapClassInst.heapFloat[r5 + numDefine65];
                        f15 = heapClassInst.heapFloat[r4 + numDefine68];
                        f10 = f10 * f6;
                        f16 = heapClassInst.heapFloat[r4 + numDefine69];
                        f17 = heapClassInst.heapFloat[r5 + numDefine68];
                        f18 = heapClassInst.heapFloat[r5 + numDefine69];
                        f19 = heapClassInst.heapFloat[r4 + numDefine66];
                        f20 = heapClassInst.heapFloat[r4 + numDefine70];
                        f21 = heapClassInst.heapFloat[r5 + numDefine66];
                        f22 = heapClassInst.heapFloat[r5 + numDefine70];
                        f11 = f11 * f7;
                        f15 = f15 * f10;
                        f23 = heapClassInst.heapFloat[r4 + numDefine72];
                        f6 = f8 * f6;
                        f8 = heapClassInst.heapFloat[r4 + numDefine73];
                        f24 = heapClassInst.heapFloat[r5 + numDefine72];
                        f25 = heapClassInst.heapFloat[r5 + numDefine73];
                        f12 = f12 * f7;
                        f16 = f16 * f10;
                        f13 = f13 * f7;
                        f17 = f17 * f10;
                        f14 = f14 * f7;
                        f18 = f18 * f10;
                        f26 = heapClassInst.heapFloat[r4 + numDefine74];
                        f27 = heapClassInst.heapFloat[r5 + numDefine74];
                        f11 = f11 + f15;
                        f15 = f23 * f6;
                        f12 = f12 + f16;
                        f8 = f8 * f6;
                        f16 = f19 * f7;
                        f19 = f20 * f10;
                        f13 = f13 + f17;
                        f17 = f24 * f6;
                        f14 = f14 + f18;
                        f18 = f25 * f6;
                        f20 = f21 * f7;
                        f21 = f22 * f10;
                        f11 = f11 + f15;
                        f8 = f12 + f8;
                        f12 = f13 + f17;
                        f13 = f14 + f18;
                        f14 = f16 + f19;
                        f15 = f26 * f6;
                        f16 = f20 + f21;
                        f17 = f27 * f6;
                        f14 = f14 + f15;
                        f15 = f16 + f17;
                        f11 = f7 * f11;
                        f8 = f10 * f8;
                        f7 = f7 * f12;
                        f10 = f10 * f13;
                        f8 = f11 + f8;
                        f11 = f6 * f14;
                        f7 = f7 + f10;
                        f6 = f6 * f15;
                        f8 = f8 + f11;
                        f6 = f7 + f6;
                        f7 = f8 + f6;
                        f7 = f7 * f7;
                        f0 = f0 * f8;
                        f3 = f3 * f6;
                        f1 = f1 * f8;
                        f5 = f5 * f6;
                        f2 = f2 * f8;
                        f4 = f4 * f6;
                        f0 = f0 - f3;
                        f3 = f9 / f7;
                        f1 = f1 - f5;
                        f2 = f2 - f4;
                        f4 = heapClassInst.heapFloat[r3 + numDefine140];
                        f0 = f0 * f3;
                        f1 = f1 * f3;
                        f2 = f2 * f3;
                        f3 = 0;
                        if (f4 >= f3) {
                            r4 = heapClassInst.heapU8[r0 + numDefine541];
                            if (r4 != 0) {
                                f4 = f4 / f8;
                            }
                            f5 = heapClassInst.heapFloat[r3 + numDefine141];
                            f6 = heapClassInst.heapFloat[r3 + numDefine142];
                            f5 = f5 + f2;
                            f6 = f6 + f1;
                            f7 = heapClassInst.heapFloat[r3 + numDefine143];
                            f7 = f7 + f0;
                            f8 = f5 * f5;
                            f9 = f6 * f6;
                            f8 = f8 + f9;
                            f9 = f7 * f7;
                            f8 = f8 + f9;
                            heapClassInst.heapFloat[g0] = f8;
                            sqrtf(i7);
                            f9 = (float) commonVariable.fg0;
                            if (f9 > f4) {
                                heapClassInst.heapFloat[g0] = f8;
                                sqrtf(i7);
                                f1 = heapClassInst.heapFloat[fp + numDefineNeg118];
                                f0 = (float) (f1 / commonVariable.fg0);
                                f1 = f7 * f0;
                                f2 = f6 * f0;
                                f0 = f5 * f0;
                                f7 = heapClassInst.heapFloat[r3 + numDefine143];
                                f1 = f1 * f4;
                                f6 = heapClassInst.heapFloat[r3 + numDefine142];
                                f2 = f2 * f4;
                                f5 = heapClassInst.heapFloat[r3 + numDefine141];
                                f4 = f0 * f4;
                                f0 = f1 - f7;
                                f1 = f2 - f6;
                                f2 = f4 - f5;
                            } else {
                                f5 = heapClassInst.heapFloat[r3 + numDefine141];
                                f6 = heapClassInst.heapFloat[r3 + numDefine142];
                                f7 = heapClassInst.heapFloat[r3 + numDefine143];
                            }
                            f4 = f5 + f2;
                            f5 = f6 + f1;
                            heapClassInst.heapFloat[r3 + numDefine141] = f4;
                            f4 = f7 + f0;
                            heapClassInst.heapFloat[r3 + numDefine142] = f5;
                            heapClassInst.heapFloat[r3 + numDefine143] = f4;
                        }
                        f4 = f2 * f2;
                        f5 = f1 * f1;
                        f4 = f4 + f5;
                        f5 = f0 * f0;
                        f4 = f4 + f5;
                        heapClassInst.heapFloat[g0] = f4;
                        sqrtf(i7);
                        f4 = (float) commonVariable.fg0;
                        f5 = heapClassInst.heapFloat[fp + numDefineNeg118];
                        f5 = f5 / f4;
                        f0 = f0 * f5;
                        f1 = f1 * f5;
                        f2 = f2 * f5;
                        f5 = heapClassInst.heapFloat[r8 + numDefine84];
                        if (!(f5 == f3)) {
                            r4 = heapClassInst.heap32[r3 + numDefine5];
                            r4 = r4 >> numDefine2;
                            f5 = f4 * f3;
                            f6 = heapClassInst.heapFloat[r8 + numDefine126];
                            f7 = heapClassInst.heapFloat[r4 + numDefine65];
                            f8 = heapClassInst.heapFloat[r4 + numDefine64];
                            f9 = heapClassInst.heapFloat[r4 + numDefine69];
                            f10 = heapClassInst.heapFloat[r4 + numDefine68];
                            f11 = heapClassInst.heapFloat[r4 + numDefine73];
                            f12 = heapClassInst.heapFloat[r4 + numDefine72];
                            f13 = heapClassInst.heapFloat[r4 + numDefine66];
                            f14 = heapClassInst.heapFloat[r4 + numDefine70];
                            f15 = heapClassInst.heapFloat[r4 + numDefine74];
                            f6 = f6 + f5;
                            heapClassInst.heapFloat[r8 + numDefine126] = f6;
                            f6 = heapClassInst.heapFloat[r8 + numDefine127];
                            f6 = f6 + f5;
                            heapClassInst.heapFloat[r8 + numDefine127] = f6;
                            f6 = heapClassInst.heapFloat[r8 + numDefine128];
                            f5 = f6 + f5;
                            heapClassInst.heapFloat[r8 + numDefine128] = f5;
                            f5 = f8 * f2;
                            f6 = f7 * f1;
                            f7 = heapClassInst.heapFloat[r8 + numDefine134];
                            f5 = f5 + f6;
                            f6 = f13 * f0;
                            f5 = f5 + f6;
                            f6 = f7 * f4;
                            f7 = heapClassInst.heapFloat[r8 + numDefine136];
                            f8 = heapClassInst.heapFloat[r8 + numDefine135];
                            f13 = heapClassInst.heapFloat[r8 + numDefine130];
                            f5 = f5 * f6;
                            f6 = f10 * f2;
                            f9 = f9 * f1;
                            f6 = f6 + f9;
                            f9 = f14 * f0;
                            f5 = f13 + f5;
                            heapClassInst.heapFloat[r8 + numDefine130] = f5;
                            f5 = f6 + f9;
                            f6 = f8 * f4;
                            f8 = f12 * f2;
                            f9 = f11 * f1;
                            f5 = f5 * f6;
                            f6 = heapClassInst.heapFloat[r8 + numDefine131];
                            f5 = f6 + f5;
                            f6 = f8 + f9;
                            f8 = f15 * f0;
                            heapClassInst.heapFloat[r8 + numDefine131] = f5;
                            f5 = f6 + f8;
                            f6 = f7 * f4;
                            f5 = f5 * f6;
                            f6 = heapClassInst.heapFloat[r8 + numDefine132];
                            f5 = f6 + f5;
                            heapClassInst.heapFloat[r8 + numDefine132] = f5;
                        }
                        f5 = heapClassInst.heapFloat[r9 + numDefine84];
                        if (!(f5 == f3)) {
                            f3 = -f4;
                            r4 = heapClassInst.heap32[r3 + numDefine6];
                            r4 = r4 >> numDefine2;
                            f5 = -0;
                            f4 = f4 * f5;
                            f5 = heapClassInst.heapFloat[r9 + numDefine126];
                            f6 = heapClassInst.heapFloat[r4 + numDefine65];
                            f7 = heapClassInst.heapFloat[r4 + numDefine64];
                            f8 = heapClassInst.heapFloat[r4 + numDefine69];
                            f9 = heapClassInst.heapFloat[r4 + numDefine68];
                            f10 = heapClassInst.heapFloat[r4 + numDefine73];
                            f11 = heapClassInst.heapFloat[r4 + numDefine72];
                            f12 = heapClassInst.heapFloat[r4 + numDefine66];
                            f13 = heapClassInst.heapFloat[r4 + numDefine70];
                            f14 = heapClassInst.heapFloat[r4 + numDefine74];
                            f5 = f5 + f4;
                            heapClassInst.heapFloat[r9 + numDefine126] = f5;
                            f5 = heapClassInst.heapFloat[r9 + numDefine127];
                            f5 = f5 + f4;
                            heapClassInst.heapFloat[r9 + numDefine127] = f5;
                            f5 = heapClassInst.heapFloat[r9 + numDefine128];
                            f4 = f5 + f4;
                            heapClassInst.heapFloat[r9 + numDefine128] = f4;
                            f4 = f7 * f2;
                            f5 = f6 * f1;
                            f4 = f4 + f5;
                            f5 = f12 * f0;
                            f6 = heapClassInst.heapFloat[r9 + numDefine134];
                            f4 = f4 + f5;
                            f5 = f6 * f3;
                            f6 = heapClassInst.heapFloat[r9 + numDefine136];
                            f7 = heapClassInst.heapFloat[r9 + numDefine135];
                            f12 = heapClassInst.heapFloat[r9 + numDefine130];
                            f4 = f4 * f5;
                            f5 = f9 * f2;
                            f8 = f8 * f1;
                            f5 = f5 + f8;
                            f8 = f13 * f0;
                            f4 = f12 + f4;
                            heapClassInst.heapFloat[r9 + numDefine130] = f4;
                            f4 = f5 + f8;
                            f5 = f7 * f3;
                            f2 = f11 * f2;
                            f1 = f10 * f1;
                            f4 = f4 * f5;
                            f5 = heapClassInst.heapFloat[r9 + numDefine131];
                            f4 = f5 + f4;
                            f1 = f2 + f1;
                            f0 = f14 * f0;
                            heapClassInst.heapFloat[r9 + numDefine131] = f4;
                            f0 = f1 + f0;
                            f1 = f6 * f3;
                            f0 = f0 * f1;
                            f1 = heapClassInst.heapFloat[r9 + numDefine132];
                            f0 = f1 + f0;
                            heapClassInst.heapFloat[r9 + numDefine132] = f0;
                        }
                    }
                }
            } while (false);
            r1 = r1 >> numDefine2;
            r2 = r2 >> numDefine2;
            f0 = heapClassInst.heapFloat[r1 + numDefine82];
            f1 = heapClassInst.heapFloat[r1 + numDefine132];
            f2 = heapClassInst.heapFloat[r1 + numDefine81];
            f3 = heapClassInst.heapFloat[r1 + numDefine131];
            f4 = heapClassInst.heapFloat[r1 + numDefine80];
            f5 = heapClassInst.heapFloat[r1 + numDefine130];
            f6 = heapClassInst.heapFloat[r2 + numDefine82];
            f7 = heapClassInst.heapFloat[r2 + numDefine132];
            f8 = heapClassInst.heapFloat[r2 + numDefine81];
            f9 = heapClassInst.heapFloat[r2 + numDefine131];
            f10 = heapClassInst.heapFloat[r2 + numDefine80];
            f11 = heapClassInst.heapFloat[r2 + numDefine130];
            f0 = f0 + f1;
            f1 = f2 + f3;
            f2 = f4 + f5;
            f3 = f6 + f7;
            f4 = f8 + f9;
            f5 = f10 + f11;
            r4 = heapClassInst.heapU8[r0 + numDefine514];
            if (!(r4 == 0)) {
                f6 = heapClassInst.heapFloat[r3 + numDefine129];
                f7 = heapClassInst.heapFloat[r3 + numDefine123];
                f8 = heapClassInst.heapFloat[r3 + numDefine112];
                f9 = f5 - f2;
                f10 = heapClassInst.heapFloat[r3 + numDefine113];
                f11 = f4 - f1;
                f12 = heapClassInst.heapFloat[r3 + numDefine114];
                f13 = f3 - f0;
                f9 = f9 * f8;
                f11 = f11 * f10;
                f7 = f6 * f7;
                f14 = heapClassInst.heapFloat[r3 + numDefine105];
                f9 = f9 + f11;
                f11 = f13 * f12;
                f7 = f7 * f14;
                f9 = f9 + f11;
                f11 = heapClassInst.heapFloat[fp + numDefineNeg117];
                f7 = f7 / f11;
                f11 = 0;
                if (f9 > f11) {
                    f6 = f6 * f9;
                    f9 = heapClassInst.heapFloat[r3 + numDefine106];
                    f6 = f6 * f9;
                    f7 = f6 + f7;
                }
                f6 = heapClassInst.heapFloat[r3 + numDefine120];
                f9 = heapClassInst.heapFloat[r3 + numDefine126];
                f6 = f6 * f7;
                f6 = f9 + f6;
                f6 = f6 > f11 ? f6 : f11;
                heapClassInst.heapFloat[r3 + numDefine126] = f6;
                f6 = f6 - f9;
                f7 = f8 * f6;
                f8 = heapClassInst.heapFloat[r3 + numDefine131];
                f9 = f10 * f6;
                f10 = heapClassInst.heapFloat[r3 + numDefine132];
                f13 = heapClassInst.heapFloat[r3 + numDefine133];
                f6 = f12 * f6;
                f12 = f7 * f8;
                f14 = f9 * f10;
                f12 = f12 + f14;
                f14 = f6 * f13;
                f12 = f12 + f14;
                f10 = f10 * f12;
                f8 = f8 * f12;
                f12 = f13 * f12;
                f9 = f9 - f10;
                f7 = f7 - f8;
                f6 = f6 - f12;
                f8 = f7 * f7;
                f10 = f9 * f9;
                f8 = f8 + f10;
                f10 = f6 * f6;
                f8 = f8 + f10;
                heapClassInst.heapFloat[g0] = f8;
                sqrtf(i7);
                f8 = (float) commonVariable.fg0;
                f10 = 1;
                f10 = f10 / f8;
                f6 = f6 * f10;
                f9 = f9 * f10;
                f7 = f7 * f10;
                f10 = heapClassInst.heapFloat[r1 + numDefine84];
                if (!(f10 == f11)) {
                    r4 = heapClassInst.heap32[r3 + numDefine5];
                    r4 = r4 >> numDefine2;
                    f10 = f8 * f11;
                    f12 = heapClassInst.heapFloat[r1 + numDefine126];
                    f13 = heapClassInst.heapFloat[r4 + numDefine65];
                    f14 = heapClassInst.heapFloat[r4 + numDefine64];
                    f15 = heapClassInst.heapFloat[r4 + numDefine69];
                    f16 = heapClassInst.heapFloat[r4 + numDefine68];
                    f17 = heapClassInst.heapFloat[r4 + numDefine73];
                    f18 = heapClassInst.heapFloat[r4 + numDefine72];
                    f19 = heapClassInst.heapFloat[r4 + numDefine66];
                    f20 = heapClassInst.heapFloat[r4 + numDefine70];
                    f21 = heapClassInst.heapFloat[r4 + numDefine74];
                    f12 = f12 + f10;
                    heapClassInst.heapFloat[r1 + numDefine126] = f12;
                    f12 = heapClassInst.heapFloat[r1 + numDefine127];
                    f12 = f12 + f10;
                    heapClassInst.heapFloat[r1 + numDefine127] = f12;
                    f12 = heapClassInst.heapFloat[r1 + numDefine128];
                    f10 = f12 + f10;
                    heapClassInst.heapFloat[r1 + numDefine128] = f10;
                    f10 = f14 * f7;
                    f12 = f13 * f9;
                    f13 = heapClassInst.heapFloat[r1 + numDefine134];
                    f10 = f10 + f12;
                    f12 = f19 * f6;
                    f10 = f10 + f12;
                    f12 = f13 * f8;
                    f13 = heapClassInst.heapFloat[r1 + numDefine136];
                    f14 = heapClassInst.heapFloat[r1 + numDefine135];
                    f19 = heapClassInst.heapFloat[r1 + numDefine130];
                    f10 = f10 * f12;
                    f12 = f16 * f7;
                    f15 = f15 * f9;
                    f12 = f12 + f15;
                    f15 = f20 * f6;
                    f10 = f19 + f10;
                    heapClassInst.heapFloat[r1 + numDefine130] = f10;
                    f10 = f12 + f15;
                    f12 = f14 * f8;
                    f14 = f18 * f7;
                    f15 = f17 * f9;
                    f10 = f10 * f12;
                    f12 = heapClassInst.heapFloat[r1 + numDefine131];
                    f10 = f12 + f10;
                    f12 = f14 + f15;
                    f14 = f21 * f6;
                    heapClassInst.heapFloat[r1 + numDefine131] = f10;
                    f10 = f12 + f14;
                    f12 = f13 * f8;
                    f10 = f10 * f12;
                    f12 = heapClassInst.heapFloat[r1 + numDefine132];
                    f10 = f12 + f10;
                    heapClassInst.heapFloat[r1 + numDefine132] = f10;
                }
                f10 = heapClassInst.heapFloat[r2 + numDefine84];
                if (!(f10 == f11)) {
                    f10 = -f8;
                    r4 = heapClassInst.heap32[r3 + numDefine6];
                    r4 = r4 >> numDefine2;
                    f11 = -0;
                    f8 = f8 * f11;
                    f11 = heapClassInst.heapFloat[r2 + numDefine126];
                    f12 = heapClassInst.heapFloat[r4 + numDefine65];
                    f13 = heapClassInst.heapFloat[r4 + numDefine64];
                    f14 = heapClassInst.heapFloat[r4 + numDefine69];
                    f15 = heapClassInst.heapFloat[r4 + numDefine68];
                    f16 = heapClassInst.heapFloat[r4 + numDefine73];
                    f17 = heapClassInst.heapFloat[r4 + numDefine72];
                    f18 = heapClassInst.heapFloat[r4 + numDefine66];
                    f19 = heapClassInst.heapFloat[r4 + numDefine70];
                    f20 = heapClassInst.heapFloat[r4 + numDefine74];
                    f11 = f11 + f8;
                    heapClassInst.heapFloat[r2 + numDefine126] = f11;
                    f11 = heapClassInst.heapFloat[r2 + numDefine127];
                    f11 = f11 + f8;
                    heapClassInst.heapFloat[r2 + numDefine127] = f11;
                    f11 = heapClassInst.heapFloat[r2 + numDefine128];
                    f8 = f11 + f8;
                    heapClassInst.heapFloat[r2 + numDefine128] = f8;
                    f8 = f13 * f7;
                    f11 = f12 * f9;
                    f8 = f8 + f11;
                    f11 = f18 * f6;
                    f12 = heapClassInst.heapFloat[r2 + numDefine134];
                    f8 = f8 + f11;
                    f11 = f12 * f10;
                    f12 = heapClassInst.heapFloat[r2 + numDefine136];
                    f13 = heapClassInst.heapFloat[r2 + numDefine135];
                    f18 = heapClassInst.heapFloat[r2 + numDefine130];
                    f8 = f8 * f11;
                    f11 = f15 * f7;
                    f14 = f14 * f9;
                    f11 = f11 + f14;
                    f14 = f19 * f6;
                    f8 = f18 + f8;
                    heapClassInst.heapFloat[r2 + numDefine130] = f8;
                    f8 = f11 + f14;
                    f11 = f13 * f10;
                    f7 = f17 * f7;
                    f9 = f16 * f9;
                    f8 = f8 * f11;
                    f11 = heapClassInst.heapFloat[r2 + numDefine131];
                    f8 = f11 + f8;
                    f7 = f7 + f9;
                    f6 = f20 * f6;
                    heapClassInst.heapFloat[r2 + numDefine131] = f8;
                    f6 = f7 + f6;
                    f7 = f12 * f10;
                    f6 = f6 * f7;
                    f7 = heapClassInst.heapFloat[r2 + numDefine132];
                    f6 = f7 + f6;
                    heapClassInst.heapFloat[r2 + numDefine132] = f6;
                }
            }
            r0 = heapClassInst.heapU8[r0 + numDefine513];
            if (!(r0 == 0)) {
                f6 = heapClassInst.heapFloat[r3 + numDefine130];
                f7 = heapClassInst.heapFloat[r3 + numDefine124];
                f8 = heapClassInst.heapFloat[r3 + numDefine116];
                f2 = f5 - f2;
                f5 = heapClassInst.heapFloat[r3 + numDefine117];
                f1 = f4 - f1;
                f4 = heapClassInst.heapFloat[r3 + numDefine118];
                f0 = f3 - f0;
                f2 = f2 * f8;
                f1 = f1 * f5;
                f3 = f6 * f7;
                f7 = heapClassInst.heapFloat[r3 + numDefine105];
                f1 = f2 + f1;
                f0 = f0 * f4;
                f2 = f3 * f7;
                f0 = f1 + f0;
                f1 = heapClassInst.heapFloat[fp + numDefineNeg117];
                f1 = f2 / f1;
                f2 = 0;
                if (f0 > f2) {
                    f0 = f6 * f0;
                    f3 = heapClassInst.heapFloat[r3 + numDefine106];
                    f0 = f0 * f3;
                    f1 = f0 + f1;
                }
                f0 = heapClassInst.heapFloat[r3 + numDefine121];
                f3 = heapClassInst.heapFloat[r3 + numDefine127];
                f0 = f0 * f1;
                f0 = f3 + f0;
                f0 = f0 > f2 ? f0 : f2;
                heapClassInst.heapFloat[r3 + numDefine127] = f0;
                f0 = f0 - f3;
                f1 = heapClassInst.heapFloat[r1 + numDefine84];
                if (f1 != f2) {
                    r0 = heapClassInst.heap32[r3 + numDefine5];
                    r0 = r0 >> numDefine2;
                    f1 = f0 * f2;
                    f3 = heapClassInst.heapFloat[r1 + numDefine126];
                    f6 = heapClassInst.heapFloat[r0 + numDefine65];
                    f7 = heapClassInst.heapFloat[r0 + numDefine64];
                    f9 = heapClassInst.heapFloat[r0 + numDefine69];
                    f10 = heapClassInst.heapFloat[r0 + numDefine68];
                    f11 = heapClassInst.heapFloat[r0 + numDefine73];
                    f12 = heapClassInst.heapFloat[r0 + numDefine72];
                    f13 = heapClassInst.heapFloat[r0 + numDefine66];
                    f14 = heapClassInst.heapFloat[r0 + numDefine70];
                    f15 = heapClassInst.heapFloat[r0 + numDefine74];
                    f3 = f3 + f1;
                    heapClassInst.heapFloat[r1 + numDefine126] = f3;
                    f3 = heapClassInst.heapFloat[r1 + numDefine127];
                    f3 = f3 + f1;
                    heapClassInst.heapFloat[r1 + numDefine127] = f3;
                    f3 = heapClassInst.heapFloat[r1 + numDefine128];
                    f1 = f3 + f1;
                    heapClassInst.heapFloat[r1 + numDefine128] = f1;
                    f1 = f7 * f8;
                    f3 = f6 * f5;
                    f6 = heapClassInst.heapFloat[r1 + numDefine134];
                    f1 = f1 + f3;
                    f3 = f13 * f4;
                    f1 = f1 + f3;
                    f3 = f6 * f0;
                    f6 = heapClassInst.heapFloat[r1 + numDefine136];
                    f7 = heapClassInst.heapFloat[r1 + numDefine135];
                    f13 = heapClassInst.heapFloat[r1 + numDefine130];
                    f1 = f1 * f3;
                    f3 = f10 * f8;
                    f9 = f9 * f5;
                    f3 = f3 + f9;
                    f9 = f14 * f4;
                    f1 = f13 + f1;
                    heapClassInst.heapFloat[r1 + numDefine130] = f1;
                    f1 = f3 + f9;
                    f3 = f7 * f0;
                    f8 = f12 * f8;
                    f5 = f11 * f5;
                    f1 = f1 * f3;
                    f3 = heapClassInst.heapFloat[r1 + numDefine131];
                    f1 = f3 + f1;
                    f5 = f8 + f5;
                    f4 = f15 * f4;
                    heapClassInst.heapFloat[r1 + numDefine131] = f1;
                    f4 = f5 + f4;
                    f5 = f6 * f0;
                    f4 = f4 * f5;
                    f5 = heapClassInst.heapFloat[r1 + numDefine132];
                    f4 = f5 + f4;
                    heapClassInst.heapFloat[r1 + numDefine132] = f4;
                    f8 = heapClassInst.heapFloat[r3 + numDefine116];
                    f5 = heapClassInst.heapFloat[r3 + numDefine117];
                    f4 = heapClassInst.heapFloat[r3 + numDefine118];
                }
                f1 = heapClassInst.heapFloat[r2 + numDefine84];
                if (!(f1 == f2)) {
                    f1 = -f0;
                    r0 = heapClassInst.heap32[r3 + numDefine6];
                    r0 = r0 >> numDefine2;
                    f2 = -0;
                    f0 = f0 * f2;
                    f2 = heapClassInst.heapFloat[r2 + numDefine126];
                    f3 = heapClassInst.heapFloat[r0 + numDefine65];
                    f6 = heapClassInst.heapFloat[r0 + numDefine64];
                    f7 = heapClassInst.heapFloat[r0 + numDefine69];
                    f9 = heapClassInst.heapFloat[r0 + numDefine68];
                    f10 = heapClassInst.heapFloat[r0 + numDefine73];
                    f11 = heapClassInst.heapFloat[r0 + numDefine72];
                    f12 = heapClassInst.heapFloat[r0 + numDefine66];
                    f13 = heapClassInst.heapFloat[r0 + numDefine70];
                    f14 = heapClassInst.heapFloat[r0 + numDefine74];
                    f2 = f2 + f0;
                    heapClassInst.heapFloat[r2 + numDefine126] = f2;
                    f2 = heapClassInst.heapFloat[r2 + numDefine127];
                    f2 = f2 + f0;
                    heapClassInst.heapFloat[r2 + numDefine127] = f2;
                    f2 = heapClassInst.heapFloat[r2 + numDefine128];
                    f0 = f2 + f0;
                    heapClassInst.heapFloat[r2 + numDefine128] = f0;
                    f0 = f6 * f8;
                    f2 = f3 * f5;
                    f0 = f0 + f2;
                    f2 = f12 * f4;
                    f3 = heapClassInst.heapFloat[r2 + numDefine134];
                    f0 = f0 + f2;
                    f2 = f3 * f1;
                    f3 = heapClassInst.heapFloat[r2 + numDefine136];
                    f6 = heapClassInst.heapFloat[r2 + numDefine135];
                    f12 = heapClassInst.heapFloat[r2 + numDefine130];
                    f0 = f0 * f2;
                    f2 = f9 * f8;
                    f7 = f7 * f5;
                    f2 = f2 + f7;
                    f7 = f13 * f4;
                    f0 = f12 + f0;
                    heapClassInst.heapFloat[r2 + numDefine130] = f0;
                    f0 = f2 + f7;
                    f2 = f6 * f1;
                    f6 = f11 * f8;
                    f5 = f10 * f5;
                    f0 = f0 * f2;
                    f2 = heapClassInst.heapFloat[r2 + numDefine131];
                    f0 = f2 + f0;
                    f2 = f6 + f5;
                    f4 = f14 * f4;
                    heapClassInst.heapFloat[r2 + numDefine131] = f0;
                    f0 = f2 + f4;
                    f1 = f3 * f1;
                    f0 = f0 * f1;
                    f1 = heapClassInst.heapFloat[r2 + numDefine132];
                    f0 = f1 + f0;
                    heapClassInst.heapFloat[r2 + numDefine132] = f0;
                }
            }
        }
        return;
    }

    public static void zn21btConeTwistConstraint8setParamEifi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        float f0 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp];
        f0 = heapClassInst.heapFloat[fp + numDefine2];
        r2 = heapClassInst.heap32[fp + numDefine3];
        r3 = (r0 + numDefineNeg3) | 0;
        if (uint(r3) < uint(numDefine2)) {
            if (uint(r2) > uint(numDefine2)) {
                r0 = r1 >> numDefine2;
                heapClassInst.heapFloat[r0 + numDefine148] = f0;
                r1 = heapClassInst.heap32[r0 + numDefine145];
                r1 = r1 | numDefine4;
                heapClassInst.heap32[r0 + numDefine145] = r1;
                return;
            } else {
                r1 = r1 >> numDefine2;
                heapClassInst.heapFloat[r1 + numDefine146] = f0;
                r0 = heapClassInst.heap32[r1 + numDefine145];
                r0 = r0 | 1;
                heapClassInst.heap32[r1 + numDefine145] = r0;
                return;
            }
        } else {
            r0 = (r0 + -1) | 0;
            if (uint(r0) > uint(1)) {
                r0 = twoEStr10;
                r1 = twoEStr24;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine1066;
                assertNew(i7);
            } else {
                if (uint(r2) > uint(numDefine2)) {
                    r1 = r1 >> numDefine2;
                    heapClassInst.heapFloat[r1 + numDefine105] = f0;
                    return;
                } else {
                    r1 = r1 >> numDefine2;
                    heapClassInst.heapFloat[r1 + numDefine147] = f0;
                    r2 = heapClassInst.heap32[r1 + numDefine145];
                    r2 = r2 | numDefine2;
                    heapClassInst.heap32[r1 + numDefine145] = r2;
                    return;
                }
            }
        }
    }

    public static void znk21btConeTwistConstraint8getParamEii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        float f0 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp];
        r2 = heapClassInst.heap32[fp + numDefine2];
        r3 = (r0 + numDefineNeg3) | 0;
        if (uint(r3) < uint(numDefine2)) {
            if (uint(r2) > uint(numDefine2)) {
                r0 = (r2 + numDefineNeg3) | 0;
                if (uint(r0) > uint(numDefine2)) {
                    r1 = twoEStr10;
                    r0 = twoEStr24;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = r0;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine1107;
                    assertNew(i7);
                } else {
                    r0 = heapClassInst.heapU8[r1 + numDefine580];
                    r0 = r0 & numDefine4;
                    if (r0 != 0) {
                        r1 = (r1 + numDefine592) | 0;
                    } else {
                        r1 = twoEStr543;
                        r0 = twoEStr24;
                        heapClassInst.heap32[g0] = r1;
                        heapClassInst.heap32[g0 + 1] = r0;
                        heapClassInst.heap32[g0 + numDefine2] = numDefine1102;
                        assertNew(i7);
                    }
                }
            } else {
                r2 = heapClassInst.heapU8[r1 + numDefine580];
                r2 = r2 & 1;
                if (r2 != 0) {
                    r1 = (r1 + numDefine584) | 0;
                } else {
                    r1 = twoEStr442;
                    r2 = twoEStr24;
                    heapClassInst.heap32[g0] = r1;
                    heapClassInst.heap32[g0 + 1] = r2;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine1097;
                    assertNew(i7);
                }
            }
        } else {
            r0 = (r0 + -1) | 0;
            if (uint(r0) > uint(1)) {
                r1 = twoEStr10;
                r0 = twoEStr24;
                heapClassInst.heap32[g0] = r1;
                heapClassInst.heap32[g0 + 1] = r0;
                heapClassInst.heap32[g0 + numDefine2] = numDefine1111;
                assertNew(i7);
            } else {
                if (uint(r2) > uint(numDefine2)) {
                    r2 = (r2 + numDefineNeg3) | 0;
                    if (uint(r2) > uint(numDefine2)) {
                        r1 = twoEStr10;
                        r2 = twoEStr24;
                        heapClassInst.heap32[g0] = r1;
                        heapClassInst.heap32[g0 + 1] = r2;
                        heapClassInst.heap32[g0 + numDefine2] = numDefine1090;
                        assertNew(i7);
                    } else {
                        r1 = (r1 + numDefine420) | 0;
                    }
                } else {
                    r2 = heapClassInst.heapU8[r1 + numDefine580];
                    r2 = r2 & numDefine2;
                    if (r2 != 0) {
                        r1 = (r1 + numDefine588) | 0;
                    } else {
                        r1 = twoEStr1340;
                        r2 = twoEStr24;
                        heapClassInst.heap32[g0] = r1;
                        heapClassInst.heap32[g0 + 1] = r2;
                        heapClassInst.heap32[g0 + numDefine2] = numDefine1081;
                        assertNew(i7);
                    }
                }
            }
        }
        r0 = r1 >> numDefine2;
        f0 = heapClassInst.heapFloat[r0];
        commonVariable.fg0 = f0;
        return;
    }

    public static void zn15btJacobianEntryC2ERK11btMatrix3x3S2RK9btVector3S5S5S5FS5F(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine5];
        r1 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        f0 = heapClassInst.heapFloat[r0];
        heapClassInst.heapFloat[r1] = f0;
        f1 = heapClassInst.heapFloat[r0 + 1];
        heapClassInst.heapFloat[r1 + 1] = f1;
        f2 = heapClassInst.heapFloat[r0 + numDefine2];
        r2 = heapClassInst.heap32[fp + numDefine3];
        heapClassInst.heapFloat[r1 + numDefine2] = f2;
        r2 = r2 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine3] = heapClassInst.heap32[r0 + numDefine3];
        f3 = heapClassInst.heapFloat[r2];
        f4 = heapClassInst.heapFloat[r2 + 1];
        f5 = heapClassInst.heapFloat[r2 + numDefine2];
        r0 = heapClassInst.heap32[fp + 1];
        r0 = r0 >> numDefine2;
        f6 = f4 * f2;
        f7 = f5 * f1;
        f5 = f5 * f0;
        f8 = f3 * f2;
        f6 = f6 - f7;
        f7 = heapClassInst.heapFloat[r0];
        f5 = f5 - f8;
        f8 = heapClassInst.heapFloat[r0 + 1];
        f3 = f3 * f1;
        f4 = f4 * f0;
        f9 = heapClassInst.heapFloat[r0 + numDefine4];
        f10 = heapClassInst.heapFloat[r0 + numDefine5];
        f7 = f7 * f6;
        f8 = f8 * f5;
        f3 = f3 - f4;
        f4 = heapClassInst.heapFloat[r0 + numDefine2];
        f11 = heapClassInst.heapFloat[r0 + numDefine8];
        f12 = heapClassInst.heapFloat[r0 + numDefine9];
        f13 = heapClassInst.heapFloat[r0 + numDefine10];
        f14 = heapClassInst.heapFloat[r0 + numDefine6];
        f9 = f9 * f6;
        f10 = f10 * f5;
        f7 = f7 + f8;
        f4 = f4 * f3;
        f6 = f11 * f6;
        f5 = f12 * f5;
        f8 = f9 + f10;
        f9 = f14 * f3;
        f4 = f7 + f4;
        f5 = f6 + f5;
        f3 = f13 * f3;
        f6 = f8 + f9;
        heapClassInst.heapFloat[r1 + numDefine4] = f4;
        f3 = f5 + f3;
        heapClassInst.heapFloat[r1 + numDefine5] = f6;
        r0 = heapClassInst.heap32[fp + numDefine4];
        heapClassInst.heapFloat[r1 + numDefine6] = f3;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine7] = 0;
        f5 = heapClassInst.heapFloat[r0];
        f7 = heapClassInst.heapFloat[r0 + 1];
        f8 = heapClassInst.heapFloat[r0 + numDefine2];
        r0 = heapClassInst.heap32[fp + numDefine2];
        r0 = r0 >> numDefine2;
        f9 = f8 * f1;
        f10 = f7 * f2;
        f2 = f5 * f2;
        f8 = f8 * f0;
        f9 = f9 - f10;
        f10 = heapClassInst.heapFloat[r0];
        f2 = f2 - f8;
        f8 = heapClassInst.heapFloat[r0 + 1];
        f0 = f7 * f0;
        f1 = f5 * f1;
        f5 = heapClassInst.heapFloat[r0 + numDefine4];
        f7 = heapClassInst.heapFloat[r0 + numDefine5];
        f10 = f10 * f9;
        f8 = f8 * f2;
        f0 = f0 - f1;
        f1 = heapClassInst.heapFloat[r0 + numDefine2];
        f11 = heapClassInst.heapFloat[r0 + numDefine8];
        f12 = heapClassInst.heapFloat[r0 + numDefine9];
        f13 = heapClassInst.heapFloat[r0 + numDefine10];
        f14 = heapClassInst.heapFloat[r0 + numDefine6];
        f5 = f5 * f9;
        f7 = f7 * f2;
        f8 = f10 + f8;
        f1 = f1 * f0;
        f9 = f11 * f9;
        f2 = f12 * f2;
        f5 = f5 + f7;
        f7 = f14 * f0;
        f1 = f8 + f1;
        f2 = f9 + f2;
        f0 = f13 * f0;
        f5 = f5 + f7;
        heapClassInst.heapFloat[r1 + numDefine8] = f1;
        f0 = f2 + f0;
        heapClassInst.heapFloat[r1 + numDefine9] = f5;
        r0 = heapClassInst.heap32[fp + numDefine6];
        heapClassInst.heapFloat[r1 + numDefine10] = f0;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine11] = 0;
        f2 = heapClassInst.heapFloat[r0 + numDefine2];
        f7 = heapClassInst.heapFloat[r0 + 1];
        f8 = heapClassInst.heapFloat[r0];
        f8 = f8 * f4;
        f7 = f7 * f6;
        heapClassInst.heapFloat[r1 + numDefine12] = f8;
        f2 = f2 * f3;
        heapClassInst.heapFloat[r1 + numDefine13] = f7;
        r0 = heapClassInst.heap32[fp + numDefine8];
        heapClassInst.heapFloat[r1 + numDefine14] = f2;
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine15] = 0;
        f9 = heapClassInst.heapFloat[r0 + numDefine2];
        f10 = heapClassInst.heapFloat[r0 + 1];
        f11 = heapClassInst.heapFloat[r0];
        f4 = f8 * f4;
        f6 = f7 * f6;
        f7 = f10 * f5;
        f8 = f11 * f1;
        f4 = f4 + f6;
        f2 = f2 * f3;
        f3 = f9 * f0;
        heapClassInst.heapFloat[r1 + numDefine16] = f8;
        f2 = f4 + f2;
        f4 = heapClassInst.heapFloat[fp + numDefine7];
        f1 = f8 * f1;
        f5 = f7 * f5;
        heapClassInst.heapFloat[r1 + numDefine17] = f7;
        f2 = f2 + f4;
        f4 = heapClassInst.heapFloat[fp + numDefine9];
        f1 = f1 + f5;
        f0 = f3 * f0;
        heapClassInst.heapFloat[r1 + numDefine18] = f3;
        f2 = f2 + f4;
        f0 = f1 + f0;
        f0 = f2 + f0;
        heapClassInst.heap32[r1 + numDefine19] = 0;
        f1 = 0;
        heapClassInst.heapFloat[r1 + numDefine20] = f0;
        if (f0 > f1) {
            return;
        } else {
            r0 = twoEStr846;
            r1 = twoEStr947;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine53;
            assertNew(i7);
        }
    }

    public static void znk21btConeTwistConstraint16GetPointForAngleEff(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        f0 = heapClassInst.heapFloat[fp + numDefine2];
        heapClassInst.heapFloat[g0] = f0;
        cosf(i7);
        f1 = (float) commonVariable.fg0;
        r0 = heapClassInst.heap32[fp + 1];
        heapClassInst.heapFloat[g0] = f0;
        sinf(i7);
        f0 = (float) commonVariable.fg0;
        r0 = r0 >> numDefine2;
        r1 = heapClassInst.heap32[fp];
        f2 = heapClassInst.heapFloat[fp + numDefine3];
        f3 = f1;
        f3 = Math.abs(f3);
        f4 = (float) numDefineFloat1257;
        if (f3 > f4) {
            f3 = heapClassInst.heapFloat[r0 + numDefine109];
            f4 = heapClassInst.heapFloat[r0 + numDefine108];
            f5 = f0 * f0;
            f6 = f1 * f1;
            f5 = f5 / f6;
            f4 = f4 * f4;
            f6 = 1;
            f3 = f3 * f3;
            f4 = f5 / f4;
            f3 = f6 / f3;
            f5 = f5 + f6;
            f3 = f4 + f3;
            f3 = f5 / f3;
            heapClassInst.heapFloat[g0] = f3;
            sqrtf(i7);
            f3 = (float) commonVariable.fg0;
        } else {
            f3 = heapClassInst.heapFloat[r0 + numDefine108];
        }
        f4 = 0;
        f5 = f1 * f1;
        f5 = f5 + f4;
        f6 = f0 * f0;
        f5 = f5 + f6;
        heapClassInst.heapFloat[g0] = f5;
        sqrtf(i7);
        f5 = (float) commonVariable.fg0;
        if (f5 != f4) {
            f6 = (float) numDefineFloat05;
            f3 = f3 * f6;
            heapClassInst.heapFloat[g0] = f3;
            sinf(i7);
            f5 = (float) (commonVariable.fg0 / f5);
            f6 = f5 * f4;
            heapClassInst.heapFloat[g0] = f3;
            f0 = -f0;
            f1 = f1 * f5;
            cosf(i7);
            f7 = -f6;
            f0 = f5 * f0;
            f5 = (float) (commonVariable.fg0 * f2);
            f8 = f1 * f4;
            f7 = f2 * f7;
            f5 = f5 + f8;
            f9 = f0 * f4;
            f7 = f7 - f8;
            f8 = f0 * f2;
            f10 = (float) (commonVariable.fg0 * f4);
            f5 = f5 - f9;
            f7 = f7 - f9;
            f4 = f6 * f4;
            f8 = f10 + f8;
            f8 = f8 - f4;
            f9 = (float) (f5 * commonVariable.fg0);
            f11 = f7 * f6;
            f4 = f10 + f4;
            f2 = f1 * f2;
            f2 = f4 - f2;
            f4 = (float) (f8 * commonVariable.fg0);
            f10 = f7 * f1;
            f9 = f9 - f11;
            f11 = f8 * f0;
            f3 = (float) (f2 * commonVariable.fg0);
            f7 = f7 * f0;
            f4 = f4 - f10;
            f10 = f2 * f6;
            f9 = f9 - f11;
            f2 = f2 * f1;
            r0 = r1 >> numDefine2;
            f2 = f9 + f2;
            f3 = f3 - f7;
            f1 = f5 * f1;
            f4 = f4 - f10;
            f0 = f5 * f0;
            f1 = f3 - f1;
            f3 = f8 * f6;
            f0 = f4 + f0;
            heapClassInst.heapFloat[r0] = f2;
            f1 = f1 + f3;
            heapClassInst.heapFloat[r0 + 1] = f0;
            heapClassInst.heapFloat[r0 + numDefine2] = f1;
            heapClassInst.heap32[r0 + numDefine3] = 0;
            return;
        } else {
            r1 = twoEStr115;
            r0 = twoEStr685;
            heapClassInst.heap32[g0] = r1;
            heapClassInst.heap32[g0 + 1] = r0;
            heapClassInst.heap32[g0 + numDefine2] = numDefine61;
            assertNew(i7);
        }
    }

    public static void zn21btConeTwistConstraint14calcAngleInfo2ERK11btTransformS2RK11btMatrix3x3S5(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        float f30 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg384;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        heapClassInst.heap32[r1 + numDefine123] = 0;
        r2 = 0;
        heapClassInst.heap32[r1 + numDefine122] = 0;
        r3 = heapClassInst.heap32[fp + 1];
        r4 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap8[r0 + numDefine513] = (byte) r2;
        heapClassInst.heap8[r0 + numDefine514] = (byte) r2;
        r2 = heapClassInst.heapU8[r0 + numDefine540];
        if (r2 == 0) {
            label = numDefine6;
        } else {
            r2 = heapClassInst.heapU8[r0 + numDefine515];
            if (r2 != 0) {
                label = numDefine6;
            } else {
                f0 = heapClassInst.heapFloat[r1 + numDefine136];
                f1 = heapClassInst.heapFloat[r1 + numDefine137];
                f2 = heapClassInst.heapFloat[r1 + numDefine138];
                f3 = f0 * f0;
                f4 = f1 * f1;
                f5 = heapClassInst.heapFloat[r1 + numDefine139];
                f3 = f3 + f4;
                f4 = f2 * f2;
                f3 = f3 + f4;
                f4 = f5 * f5;
                f6 = numDefine2;
                f3 = f3 + f4;
                r4 = r4 >> numDefine2;
                f3 = f6 / f3;
                f4 = f2 * f3;
                f6 = f1 * f3;
                f3 = f0 * f3;
                f7 = heapClassInst.heapFloat[r4];
                heapClassInst.heapFloat[fp + numDefineNeg48] = f7;
                f7 = heapClassInst.heapFloat[r1 + numDefine89];
                heapClassInst.heapFloat[fp + numDefineNeg64] = f7;
                f7 = heapClassInst.heapFloat[r1 + numDefine88];
                heapClassInst.heapFloat[fp + numDefineNeg66] = f7;
                f8 = heapClassInst.heapFloat[r4 + 1];
                heapClassInst.heapFloat[fp + numDefineNeg49] = f8;
                f9 = heapClassInst.heapFloat[r1 + numDefine93];
                heapClassInst.heapFloat[fp + numDefineNeg65] = f9;
                f7 = heapClassInst.heapFloat[r1 + numDefine92];
                heapClassInst.heapFloat[fp + numDefineNeg67] = f7;
                f8 = heapClassInst.heapFloat[r1 + numDefine90];
                heapClassInst.heapFloat[fp + numDefineNeg54] = f8;
                f9 = heapClassInst.heapFloat[r1 + numDefine94];
                heapClassInst.heapFloat[fp + numDefineNeg55] = f9;
                f2 = f2 * f4;
                f10 = f0 * f3;
                f11 = f1 * f6;
                f12 = heapClassInst.heapFloat[fp + numDefineNeg66];
                f7 = heapClassInst.heapFloat[fp + numDefineNeg48];
                f13 = f12 * f7;
                f7 = heapClassInst.heapFloat[fp + numDefineNeg67];
                f8 = heapClassInst.heapFloat[fp + numDefineNeg49];
                f14 = f7 * f8;
                f15 = heapClassInst.heapFloat[fp + numDefineNeg64];
                f7 = heapClassInst.heapFloat[fp + numDefineNeg48];
                f16 = f15 * f7;
                f9 = heapClassInst.heapFloat[fp + numDefineNeg65];
                f17 = f9 * f8;
                f18 = heapClassInst.heapFloat[r4 + numDefine2];
                heapClassInst.heapFloat[fp + numDefineNeg83] = f18;
                f19 = heapClassInst.heapFloat[r1 + numDefine97];
                heapClassInst.heapFloat[fp + numDefineNeg80] = f19;
                f20 = heapClassInst.heapFloat[r1 + numDefine96];
                heapClassInst.heapFloat[fp + numDefineNeg81] = f20;
                r3 = r3 >> numDefine2;
                f21 = heapClassInst.heapFloat[r1 + numDefine98];
                heapClassInst.heapFloat[fp + numDefineNeg77] = f21;
                f22 = f11 + f2;
                f23 = 1;
                heapClassInst.heapFloat[fp + numDefineNeg76] = f23;
                f2 = f10 + f2;
                f24 = f0 * f6;
                f25 = f5 * f4;
                f13 = f13 + f14;
                f14 = f20 * f18;
                f16 = f16 + f17;
                f17 = f19 * f18;
                f8 = heapClassInst.heapFloat[fp + numDefineNeg54];
                f26 = f8 * f7;
                f9 = heapClassInst.heapFloat[fp + numDefineNeg55];
                f8 = heapClassInst.heapFloat[fp + numDefineNeg49];
                f27 = f9 * f8;
                f22 = f23 - f22;
                heapClassInst.heapFloat[fp + numDefineNeg78] = f22;
                f13 = f13 + f14;
                heapClassInst.heapFloat[fp + numDefineNeg50] = f13;
                f14 = f24 - f25;
                heapClassInst.heapFloat[fp + numDefineNeg52] = f14;
                f24 = f24 + f25;
                heapClassInst.heapFloat[fp + numDefineNeg79] = f24;
                f16 = f16 + f17;
                heapClassInst.heapFloat[fp + numDefineNeg51] = f16;
                f2 = f23 - f2;
                heapClassInst.heapFloat[fp + numDefineNeg53] = f2;
                f0 = f0 * f4;
                f6 = f5 * f6;
                f1 = f1 * f4;
                f3 = f5 * f3;
                f4 = f26 + f27;
                f5 = f21 * f18;
                f2 = heapClassInst.heapFloat[r3];
                heapClassInst.heapFloat[fp + numDefineNeg40] = f2;
                f7 = heapClassInst.heapFloat[r1 + numDefine73];
                f8 = heapClassInst.heapFloat[r1 + numDefine72];
                f2 = heapClassInst.heapFloat[r3 + 1];
                heapClassInst.heapFloat[fp + numDefineNeg41] = f2;
                f9 = heapClassInst.heapFloat[r1 + numDefine77];
                f12 = heapClassInst.heapFloat[r1 + numDefine76];
                f13 = heapClassInst.heapFloat[r4 + numDefine4];
                heapClassInst.heapFloat[fp + numDefineNeg59] = f13;
                f14 = heapClassInst.heapFloat[r4 + numDefine5];
                heapClassInst.heapFloat[fp + numDefineNeg60] = f14;
                f15 = heapClassInst.heapFloat[r3 + numDefine4];
                heapClassInst.heapFloat[fp + numDefineNeg68] = f15;
                f16 = heapClassInst.heapFloat[r3 + numDefine5];
                heapClassInst.heapFloat[fp + numDefineNeg69] = f16;
                f17 = heapClassInst.heapFloat[r1 + numDefine74];
                f18 = heapClassInst.heapFloat[r1 + numDefine78];
                f19 = f0 + f6;
                heapClassInst.heapFloat[fp + numDefineNeg56] = f19;
                f20 = f1 - f3;
                heapClassInst.heapFloat[fp + numDefineNeg58] = f20;
                f10 = f10 + f11;
                f2 = heapClassInst.heapFloat[fp + numDefineNeg40];
                f11 = f8 * f2;
                f2 = heapClassInst.heapFloat[fp + numDefineNeg41];
                f21 = f12 * f2;
                f13 = heapClassInst.heapFloat[fp + numDefineNeg50];
                f23 = f22 * f13;
                f16 = heapClassInst.heapFloat[fp + numDefineNeg51];
                f25 = f24 * f16;
                f0 = f0 - f6;
                heapClassInst.heapFloat[fp + numDefineNeg61] = f0;
                f4 = f4 + f5;
                heapClassInst.heapFloat[fp + numDefineNeg57] = f4;
                f1 = f1 + f3;
                heapClassInst.heapFloat[fp + numDefineNeg62] = f1;
                f2 = heapClassInst.heapFloat[fp + numDefineNeg40];
                f3 = f7 * f2;
                f2 = heapClassInst.heapFloat[fp + numDefineNeg41];
                f5 = f9 * f2;
                f14 = heapClassInst.heapFloat[fp + numDefineNeg52];
                f6 = f14 * f13;
                f2 = heapClassInst.heapFloat[fp + numDefineNeg53];
                f26 = f2 * f16;
                f0 = heapClassInst.heapFloat[r3 + numDefine2];
                heapClassInst.heapFloat[fp + numDefineNeg71] = f0;
                f1 = heapClassInst.heapFloat[r1 + numDefine81];
                f2 = heapClassInst.heapFloat[r1 + numDefine80];
                f4 = heapClassInst.heapFloat[r3 + numDefine8];
                heapClassInst.heapFloat[fp + numDefineNeg38] = f4;
                f13 = heapClassInst.heapFloat[r3 + numDefine9];
                heapClassInst.heapFloat[fp + numDefineNeg39] = f13;
                f14 = heapClassInst.heapFloat[r4 + numDefine6];
                heapClassInst.heapFloat[fp + numDefineNeg37] = f14;
                f15 = heapClassInst.heapFloat[r3 + numDefine6];
                heapClassInst.heapFloat[fp + numDefineNeg70] = f15;
                f0 = heapClassInst.heapFloat[r1 + numDefine82];
                heapClassInst.heapFloat[fp + numDefineNeg82] = f0;
                f4 = heapClassInst.heapFloat[fp + numDefineNeg76];
                f10 = f4 - f10;
                heapClassInst.heapFloat[fp + numDefineNeg63] = f10;
                f14 = heapClassInst.heapFloat[fp + numDefineNeg66];
                f13 = heapClassInst.heapFloat[fp + numDefineNeg59];
                f15 = f14 * f13;
                f16 = heapClassInst.heapFloat[fp + numDefineNeg67];
                f14 = heapClassInst.heapFloat[fp + numDefineNeg60];
                f19 = f16 * f14;
                f20 = heapClassInst.heapFloat[fp + numDefineNeg64];
                f22 = f20 * f13;
                f24 = heapClassInst.heapFloat[fp + numDefineNeg65];
                f27 = f24 * f14;
                f28 = heapClassInst.heapFloat[fp + numDefineNeg68];
                f29 = f8 * f28;
                f16 = heapClassInst.heapFloat[fp + numDefineNeg69];
                f30 = f12 * f16;
                f0 = f7 * f28;
                f4 = f9 * f16;
                f11 = f11 + f21;
                heapClassInst.heapFloat[fp + numDefineNeg42] = f11;
                f21 = heapClassInst.heapFloat[fp + numDefineNeg71];
                f10 = f2 * f21;
                heapClassInst.heapFloat[fp + numDefineNeg43] = f10;
                f10 = f23 + f25;
                heapClassInst.heapFloat[fp + numDefineNeg44] = f10;
                f13 = heapClassInst.heapFloat[fp + numDefineNeg61];
                f11 = heapClassInst.heapFloat[fp + numDefineNeg57];
                f14 = f13 * f11;
                f3 = f3 + f5;
                f5 = f1 * f21;
                f6 = f6 + f26;
                f16 = heapClassInst.heapFloat[fp + numDefineNeg62];
                f20 = f16 * f11;
                f23 = heapClassInst.heapFloat[fp + numDefineNeg40];
                f24 = f17 * f23;
                f25 = heapClassInst.heapFloat[fp + numDefineNeg41];
                f26 = f18 * f25;
                f28 = heapClassInst.heapFloat[fp + numDefineNeg56];
                f13 = heapClassInst.heapFloat[fp + numDefineNeg50];
                f10 = f28 * f13;
                f11 = heapClassInst.heapFloat[fp + numDefineNeg58];
                f16 = heapClassInst.heapFloat[fp + numDefineNeg51];
                f11 = f11 * f16;
                f13 = heapClassInst.heapFloat[r3 + numDefine10];
                heapClassInst.heapFloat[fp + numDefineNeg72] = f13;
                f15 = f15 + f19;
                f13 = heapClassInst.heapFloat[fp + numDefineNeg81];
                f19 = heapClassInst.heapFloat[fp + numDefineNeg37];
                f13 = f13 * f19;
                f22 = f22 + f27;
                f19 = heapClassInst.heapFloat[fp + numDefineNeg80];
                f27 = heapClassInst.heapFloat[fp + numDefineNeg37];
                f16 = f19 * f27;
                f19 = heapClassInst.heapFloat[fp + numDefineNeg54];
                f21 = heapClassInst.heapFloat[fp + numDefineNeg59];
                f19 = f19 * f21;
                f21 = heapClassInst.heapFloat[fp + numDefineNeg55];
                f23 = heapClassInst.heapFloat[fp + numDefineNeg60];
                f21 = f21 * f23;
                f23 = heapClassInst.heapFloat[fp + numDefineNeg38];
                f8 = f8 * f23;
                f23 = heapClassInst.heapFloat[fp + numDefineNeg39];
                f12 = f12 * f23;
                f23 = heapClassInst.heapFloat[fp + numDefineNeg38];
                f7 = f7 * f23;
                f23 = heapClassInst.heapFloat[fp + numDefineNeg39];
                f9 = f9 * f23;
                f29 = f29 + f30;
                f30 = heapClassInst.heapFloat[fp + numDefineNeg70];
                f23 = f2 * f30;
                f0 = f0 + f4;
                f4 = f1 * f30;
                f28 = heapClassInst.heapFloat[fp + numDefineNeg68];
                f25 = f17 * f28;
                f27 = heapClassInst.heapFloat[fp + numDefineNeg69];
                f27 = f18 * f27;
                f28 = heapClassInst.heapFloat[fp + numDefineNeg42];
                f30 = heapClassInst.heapFloat[fp + numDefineNeg43];
                f28 = f28 + f30;
                f30 = heapClassInst.heapFloat[fp + numDefineNeg44];
                f14 = f30 + f14;
                heapClassInst.heapFloat[fp + numDefineNeg73] = f14;
                f3 = f3 + f5;
                f5 = f6 + f20;
                heapClassInst.heapFloat[fp + numDefineNeg42] = f5;
                f6 = f24 + f26;
                f20 = heapClassInst.heapFloat[fp + numDefineNeg82];
                f14 = heapClassInst.heapFloat[fp + numDefineNeg71];
                f24 = f20 * f14;
                f10 = f10 + f11;
                f26 = heapClassInst.heapFloat[fp + numDefineNeg63];
                f11 = heapClassInst.heapFloat[fp + numDefineNeg57];
                f30 = f26 * f11;
                f5 = f15 + f13;
                heapClassInst.heapFloat[fp + numDefineNeg44] = f5;
                f5 = f22 + f16;
                heapClassInst.heapFloat[fp + numDefineNeg45] = f5;
                f11 = f29 + f23;
                f0 = f0 + f4;
                f4 = f19 + f21;
                f21 = heapClassInst.heapFloat[fp + numDefineNeg77];
                f13 = heapClassInst.heapFloat[fp + numDefineNeg37];
                f14 = f21 * f13;
                f8 = f8 + f12;
                f13 = heapClassInst.heapFloat[fp + numDefineNeg72];
                f2 = f2 * f13;
                f7 = f7 + f9;
                f1 = f1 * f13;
                f23 = heapClassInst.heapFloat[fp + numDefineNeg38];
                f9 = f17 * f23;
                f23 = heapClassInst.heapFloat[fp + numDefineNeg39];
                f12 = f18 * f23;
                f15 = f25 + f27;
                f16 = heapClassInst.heapFloat[fp + numDefineNeg70];
                f17 = f20 * f16;
                f18 = heapClassInst.heapFloat[fp + numDefineNeg73];
                f19 = f28 * f18;
                f5 = heapClassInst.heapFloat[fp + numDefineNeg42];
                f22 = f3 * f5;
                f6 = f6 + f24;
                f10 = f10 + f30;
                heapClassInst.heapFloat[fp + numDefineNeg43] = f10;
                f4 = f4 + f14;
                heapClassInst.heapFloat[fp + numDefineNeg74] = f4;
                f14 = heapClassInst.heapFloat[r1 + numDefine84];
                f24 = heapClassInst.heapFloat[r1 + numDefine85];
                f25 = heapClassInst.heapFloat[r1 + numDefine86];
                f4 = heapClassInst.heapFloat[r4 + numDefine8];
                heapClassInst.heapFloat[fp + numDefineNeg46] = f4;
                f5 = heapClassInst.heapFloat[r1 + numDefine100];
                heapClassInst.heapFloat[fp + numDefineNeg85] = f5;
                f4 = heapClassInst.heapFloat[r4 + numDefine9];
                heapClassInst.heapFloat[fp + numDefineNeg47] = f4;
                f5 = heapClassInst.heapFloat[r1 + numDefine101];
                heapClassInst.heapFloat[fp + numDefineNeg86] = f5;
                f10 = heapClassInst.heapFloat[r4 + numDefine10];
                heapClassInst.heapFloat[fp + numDefineNeg75] = f10;
                f13 = heapClassInst.heapFloat[r1 + numDefine102];
                heapClassInst.heapFloat[fp + numDefineNeg84] = f13;
                f2 = f8 + f2;
                f1 = f7 + f1;
                f7 = f15 + f17;
                f8 = heapClassInst.heapFloat[fp + numDefineNeg78];
                f5 = heapClassInst.heapFloat[fp + numDefineNeg44];
                f15 = f8 * f5;
                f16 = heapClassInst.heapFloat[fp + numDefineNeg79];
                f5 = heapClassInst.heapFloat[fp + numDefineNeg45];
                f17 = f16 * f5;
                f18 = heapClassInst.heapFloat[fp + numDefineNeg52];
                f5 = heapClassInst.heapFloat[fp + numDefineNeg44];
                f20 = f18 * f5;
                f21 = heapClassInst.heapFloat[fp + numDefineNeg53];
                f5 = heapClassInst.heapFloat[fp + numDefineNeg45];
                f23 = f21 * f5;
                f9 = f9 + f12;
                f12 = heapClassInst.heapFloat[fp + numDefineNeg82];
                f13 = heapClassInst.heapFloat[fp + numDefineNeg72];
                f12 = f12 * f13;
                f18 = heapClassInst.heapFloat[fp + numDefineNeg73];
                f26 = f11 * f18;
                f5 = heapClassInst.heapFloat[fp + numDefineNeg42];
                f27 = f0 * f5;
                f19 = f19 + f22;
                f10 = heapClassInst.heapFloat[fp + numDefineNeg43];
                f22 = f6 * f10;
                f29 = heapClassInst.heapFloat[r3 + numDefine14];
                heapClassInst.heapFloat[fp + numDefineNeg82] = f29;
                f30 = heapClassInst.heapFloat[r3 + numDefine13];
                heapClassInst.heapFloat[fp + numDefineNeg87] = f30;
                f4 = heapClassInst.heapFloat[r3 + numDefine12];
                heapClassInst.heapFloat[fp + numDefineNeg89] = f4;
                f4 = heapClassInst.heapFloat[r4 + numDefine14];
                heapClassInst.heapFloat[fp + numDefineNeg88] = f4;
                f4 = heapClassInst.heapFloat[r4 + numDefine13];
                heapClassInst.heapFloat[fp + numDefineNeg90] = f4;
                f4 = heapClassInst.heapFloat[r4 + numDefine12];
                heapClassInst.heapFloat[fp + numDefineNeg91] = f4;
                r3 = sp + numDefineNeg128;
                f9 = f9 + f12;
                f12 = heapClassInst.heapFloat[fp + numDefineNeg66];
                f4 = heapClassInst.heapFloat[fp + numDefineNeg46];
                f12 = f12 * f4;
                f4 = heapClassInst.heapFloat[fp + numDefineNeg67];
                f5 = heapClassInst.heapFloat[fp + numDefineNeg47];
                f4 = f4 * f5;
                f5 = heapClassInst.heapFloat[fp + numDefineNeg64];
                f8 = heapClassInst.heapFloat[fp + numDefineNeg46];
                f5 = f5 * f8;
                f8 = heapClassInst.heapFloat[fp + numDefineNeg65];
                f10 = heapClassInst.heapFloat[fp + numDefineNeg47];
                f8 = f8 * f10;
                f15 = f15 + f17;
                f13 = heapClassInst.heapFloat[fp + numDefineNeg61];
                f17 = heapClassInst.heapFloat[fp + numDefineNeg74];
                f10 = f13 * f17;
                f20 = f20 + f23;
                f16 = heapClassInst.heapFloat[fp + numDefineNeg62];
                f23 = f16 * f17;
                f13 = heapClassInst.heapFloat[fp + numDefineNeg56];
                f16 = heapClassInst.heapFloat[fp + numDefineNeg44];
                f13 = f13 * f16;
                f16 = heapClassInst.heapFloat[fp + numDefineNeg58];
                f17 = heapClassInst.heapFloat[fp + numDefineNeg45];
                f16 = f16 * f17;
                f17 = f2 * f18;
                f18 = heapClassInst.heapFloat[fp + numDefineNeg42];
                f18 = f1 * f18;
                f26 = f26 + f27;
                f27 = heapClassInst.heapFloat[fp + numDefineNeg43];
                f21 = f7 * f27;
                f19 = f19 + f22;
                f10 = f15 + f10;
                f15 = f20 + f23;
                r4 = r3 >> numDefine2;
                f20 = heapClassInst.heapFloat[fp + numDefineNeg40];
                f20 = f20 * f14;
                f22 = heapClassInst.heapFloat[fp + numDefineNeg41];
                f22 = f22 * f24;
                f4 = f12 + f4;
                f12 = heapClassInst.heapFloat[fp + numDefineNeg81];
                f23 = heapClassInst.heapFloat[fp + numDefineNeg75];
                f12 = f12 * f23;
                f5 = f5 + f8;
                f8 = heapClassInst.heapFloat[fp + numDefineNeg80];
                f8 = f8 * f23;
                f23 = heapClassInst.heapFloat[fp + numDefineNeg54];
                f27 = heapClassInst.heapFloat[fp + numDefineNeg46];
                f23 = f23 * f27;
                f27 = heapClassInst.heapFloat[fp + numDefineNeg55];
                f29 = heapClassInst.heapFloat[fp + numDefineNeg47];
                f27 = f27 * f29;
                f13 = f13 + f16;
                f16 = heapClassInst.heapFloat[fp + numDefineNeg63];
                f29 = heapClassInst.heapFloat[fp + numDefineNeg74];
                f16 = f16 * f29;
                f17 = f17 + f18;
                f18 = heapClassInst.heapFloat[fp + numDefineNeg43];
                f18 = f9 * f18;
                f21 = f26 + f21;
                heapClassInst.heapFloat[fp + numDefineNeg32] = f19;
                f4 = f4 + f12;
                f5 = f5 + f8;
                f8 = f13 + f16;
                f12 = f20 + f22;
                f13 = heapClassInst.heapFloat[fp + numDefineNeg71];
                f13 = f13 * f25;
                f16 = heapClassInst.heapFloat[fp + numDefineNeg68];
                f16 = f16 * f14;
                f19 = heapClassInst.heapFloat[fp + numDefineNeg69];
                f19 = f19 * f24;
                f20 = f23 + f27;
                f22 = heapClassInst.heapFloat[fp + numDefineNeg77];
                f23 = heapClassInst.heapFloat[fp + numDefineNeg75];
                f22 = f22 * f23;
                f26 = f28 * f10;
                f27 = f3 * f15;
                f17 = f17 + f18;
                heapClassInst.heapFloat[r4 + 1] = f21;
                f18 = f20 + f22;
                f12 = f12 + f13;
                heapClassInst.heapFloat[r4 + numDefine2] = f17;
                f13 = f16 + f19;
                f16 = heapClassInst.heapFloat[fp + numDefineNeg70];
                f16 = f16 * f25;
                f17 = heapClassInst.heapFloat[fp + numDefineNeg38];
                f14 = f17 * f14;
                f17 = heapClassInst.heapFloat[fp + numDefineNeg39];
                f17 = f17 * f24;
                f19 = heapClassInst.heapFloat[fp + numDefineNeg78];
                f19 = f19 * f4;
                f20 = heapClassInst.heapFloat[fp + numDefineNeg79];
                f20 = f20 * f5;
                f21 = heapClassInst.heapFloat[fp + numDefineNeg52];
                f21 = f21 * f4;
                f22 = heapClassInst.heapFloat[fp + numDefineNeg53];
                f22 = f22 * f5;
                f24 = f11 * f10;
                f23 = f0 * f15;
                f26 = f26 + f27;
                f27 = f6 * f8;
                f29 = heapClassInst.heapFloat[fp + numDefineNeg89];
                f12 = f12 + f29;
                f13 = f13 + f16;
                f14 = f14 + f17;
                f16 = heapClassInst.heapFloat[fp + numDefineNeg72];
                f16 = f16 * f25;
                f17 = f19 + f20;
                f19 = heapClassInst.heapFloat[fp + numDefineNeg61];
                f19 = f19 * f18;
                f20 = f21 + f22;
                f21 = heapClassInst.heapFloat[fp + numDefineNeg62];
                f21 = f21 * f18;
                f22 = heapClassInst.heapFloat[fp + numDefineNeg56];
                f22 = f22 * f4;
                f25 = heapClassInst.heapFloat[fp + numDefineNeg58];
                f25 = f25 * f5;
                f29 = f2 * f10;
                f30 = f1 * f15;
                f23 = f24 + f23;
                f24 = f7 * f8;
                f26 = f26 + f27;
                heapClassInst.heap32[r4 + numDefine3] = 0;
                f12 = -f12;
                f27 = heapClassInst.heapFloat[fp + numDefineNeg87];
                f13 = f13 + f27;
                f17 = f17 + f19;
                f19 = f20 + f21;
                f14 = f14 + f16;
                f16 = f22 + f25;
                f20 = heapClassInst.heapFloat[fp + numDefineNeg63];
                f20 = f20 * f18;
                f21 = f29 + f30;
                f22 = f9 * f8;
                f23 = f23 + f24;
                heapClassInst.heapFloat[r4 + numDefine4] = f26;
                f29 = heapClassInst.heapFloat[fp + numDefineNeg82];
                f14 = f14 + f29;
                f16 = f16 + f20;
                f20 = f28 * f12;
                f24 = f11 * f13;
                f25 = f3 * f12;
                f26 = f0 * f13;
                f27 = f28 * f17;
                f3 = f3 * f19;
                f21 = f21 + f22;
                heapClassInst.heapFloat[r4 + numDefine5] = f23;
                f22 = 0;
                heapClassInst.heapFloat[r4 + numDefine6] = f21;
                f20 = f20 - f24;
                f21 = f2 * f14;
                f23 = f25 - f26;
                f24 = f1 * f14;
                f12 = f6 * f12;
                f13 = f7 * f13;
                f25 = heapClassInst.heapFloat[fp + numDefineNeg48];
                f26 = heapClassInst.heapFloat[fp + numDefineNeg85];
                f25 = f25 * f26;
                f28 = heapClassInst.heapFloat[fp + numDefineNeg49];
                f29 = heapClassInst.heapFloat[fp + numDefineNeg86];
                f28 = f28 * f29;
                f11 = f11 * f17;
                f0 = f0 * f19;
                f3 = f27 + f3;
                f6 = f6 * f16;
                f20 = f20 - f21;
                f21 = f23 - f24;
                f23 = heapClassInst.heapFloat[fp + numDefineNeg59];
                f23 = f23 * f26;
                f24 = heapClassInst.heapFloat[fp + numDefineNeg60];
                f24 = f24 * f29;
                f12 = f12 - f13;
                f13 = f9 * f14;
                f14 = heapClassInst.heapFloat[fp + numDefineNeg50];
                f14 = f14 * f22;
                f27 = heapClassInst.heapFloat[fp + numDefineNeg51];
                f27 = f27 * f22;
                f25 = f25 + f28;
                f28 = heapClassInst.heapFloat[fp + numDefineNeg83];
                f30 = heapClassInst.heapFloat[fp + numDefineNeg84];
                f28 = f28 * f30;
                f2 = f2 * f17;
                f1 = f1 * f19;
                f0 = f11 + f0;
                f7 = f7 * f16;
                f3 = f3 + f6;
                heapClassInst.heap32[r4 + numDefine7] = 0;
                f6 = f12 - f13;
                f11 = f25 + f28;
                f12 = heapClassInst.heapFloat[fp + numDefineNeg46];
                f12 = f12 * f26;
                f13 = heapClassInst.heapFloat[fp + numDefineNeg47];
                f13 = f13 * f29;
                f25 = heapClassInst.heapFloat[fp + numDefineNeg44];
                f25 = f25 * f22;
                f26 = heapClassInst.heapFloat[fp + numDefineNeg45];
                f26 = f26 * f22;
                f23 = f23 + f24;
                f24 = heapClassInst.heapFloat[fp + numDefineNeg37];
                f24 = f24 * f30;
                f28 = heapClassInst.heapFloat[fp + numDefineNeg73];
                f28 = f28 * f20;
                f29 = heapClassInst.heapFloat[fp + numDefineNeg42];
                f29 = f29 * f21;
                f14 = f14 + f27;
                f27 = heapClassInst.heapFloat[fp + numDefineNeg57];
                f27 = f27 * f22;
                f1 = f2 + f1;
                f2 = f9 * f16;
                f0 = f0 + f7;
                heapClassInst.heapFloat[r4 + numDefine8] = f3;
                f3 = f23 + f24;
                f4 = f4 * f22;
                f5 = f5 * f22;
                f7 = f12 + f13;
                f23 = heapClassInst.heapFloat[fp + numDefineNeg75];
                f9 = f23 * f30;
                f10 = f10 * f20;
                f12 = f15 * f21;
                f13 = f25 + f26;
                f15 = heapClassInst.heapFloat[fp + numDefineNeg74];
                f15 = f15 * f22;
                f23 = f28 + f29;
                f24 = heapClassInst.heapFloat[fp + numDefineNeg43];
                f24 = f24 * f6;
                f14 = f14 + f27;
                f25 = heapClassInst.heapFloat[fp + numDefineNeg91];
                f11 = f11 + f25;
                f1 = f1 + f2;
                heapClassInst.heapFloat[r4 + numDefine9] = f0;
                f0 = f7 + f9;
                heapClassInst.heapFloat[r4 + numDefine10] = f1;
                f1 = f17 * f20;
                f2 = f19 * f21;
                f4 = f4 + f5;
                f5 = f18 * f22;
                f7 = f10 + f12;
                f8 = f8 * f6;
                f9 = f13 + f15;
                f10 = heapClassInst.heapFloat[fp + numDefineNeg90];
                f3 = f3 + f10;
                f10 = f23 + f24;
                f11 = f14 + f11;
                f1 = f1 + f2;
                f2 = f16 * f6;
                f4 = f4 + f5;
                f5 = heapClassInst.heapFloat[fp + numDefineNeg88];
                f0 = f0 + f5;
                f5 = f7 + f8;
                f3 = f9 + f3;
                f6 = f10 + f11;
                heapClassInst.heap32[r4 + numDefine11] = 0;
                f1 = f1 + f2;
                f0 = f4 + f0;
                f2 = f5 + f3;
                heapClassInst.heapFloat[r4 + numDefine12] = f6;
                f0 = f1 + f0;
                heapClassInst.heapFloat[r4 + numDefine13] = f2;
                heapClassInst.heapFloat[r4 + numDefine14] = f0;
                heapClassInst.heap32[r4 + numDefine15] = 0;
                r4 = sp + numDefineNeg144;
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r4;
                znk11btMatrix3x311getRotationER12btQuaternion(i7);
                r3 = r4 >> numDefine2;
                f0 = heapClassInst.heapFloat[r3 + numDefine2];
                f1 = heapClassInst.heapFloat[r3 + 1];
                f2 = heapClassInst.heapFloat[fp + numDefineNeg36];
                heapClassInst.heapFloat[r1 + numDefine112] = f2;
                heapClassInst.heapFloat[r1 + numDefine113] = f1;
                heapClassInst.heapFloat[r1 + numDefine114] = f0;
                heapClassInst.heap32[r1 + numDefine115] = 0;
                f2 = f2 * f2;
                f1 = f1 * f1;
                f1 = f2 + f1;
                f0 = f0 * f0;
                f0 = f1 + f0;
                heapClassInst.heapFloat[g0] = f0;
                sqrtf(i7);
                f4 = heapClassInst.heapFloat[fp + numDefineNeg76];
                f0 = (float) (f4 / commonVariable.fg0);
                f1 = heapClassInst.heapFloat[r1 + numDefine112];
                f1 = f1 * f0;
                heapClassInst.heapFloat[r1 + numDefine112] = f1;
                f1 = heapClassInst.heapFloat[r1 + numDefine113];
                f1 = f1 * f0;
                heapClassInst.heapFloat[r1 + numDefine113] = f1;
                f1 = heapClassInst.heapFloat[r1 + numDefine114];
                f0 = f1 * f0;
                heapClassInst.heapFloat[r1 + numDefine114] = f0;
                f0 = heapClassInst.heapFloat[r3 + numDefine3];
                f1 = -1;
                f0 = f0 < f1 ? f1 : f0;
                f0 = f0 > f4 ? f4 : f0;
                heapClassInst.heapFloat[g0] = f0;
                acosf(i7);
                f0 = (float) (commonVariable.fg0 + commonVariable.fg0);
                heapClassInst.heapFloat[r1 + numDefine123] = f0;
                if (f0 < f22) {
                    f0 = -f0;
                }
                f1 = (float) numDefineFloat1257;
                if (f0 < f1) {
                    label = numDefine72;
                } else {
                    r1 = 1;
                    heapClassInst.heap8[r0 + numDefine514] = (byte) r1;
                    return;
                }
            }
        }
        repeat8: do {
            if (label == numDefine6) {
                r2 = heapClassInst.heap32[fp + numDefine3];
                r5 = heapClassInst.heap32[fp + numDefine4];
                r6 = sp + numDefineNeg64;
                r7 = (r0 + numDefine288) | 0;
                heapClassInst.heap32[g0] = r7;
                heapClassInst.heap32[g0 + 1] = r6;
                znk11btMatrix3x311getRotationER12btQuaternion(i7);
                r7 = sp + numDefineNeg48;
                heapClassInst.heap32[g0] = r3;
                heapClassInst.heap32[g0 + 1] = r7;
                znk11btMatrix3x311getRotationER12btQuaternion(i7);
                r7 = r7 >> numDefine2;
                r6 = r6 >> numDefine2;
                f0 = heapClassInst.heapFloat[r7 + numDefine3];
                f1 = heapClassInst.heapFloat[r6 + numDefine3];
                f2 = heapClassInst.heapFloat[fp + numDefineNeg12];
                f3 = heapClassInst.heapFloat[fp + numDefineNeg16];
                f4 = heapClassInst.heapFloat[r7 + 1];
                f5 = heapClassInst.heapFloat[r6 + 1];
                f6 = heapClassInst.heapFloat[r7 + numDefine2];
                f7 = heapClassInst.heapFloat[r6 + numDefine2];
                r6 = sp + numDefineNeg32;
                r7 = (r0 + numDefine352) | 0;
                heapClassInst.heap32[g0] = r7;
                heapClassInst.heap32[g0 + 1] = r6;
                znk11btMatrix3x311getRotationER12btQuaternion(i7);
                r7 = sp + numDefineNeg16;
                heapClassInst.heap32[g0] = r4;
                heapClassInst.heap32[g0 + 1] = r7;
                znk11btMatrix3x311getRotationER12btQuaternion(i7);
                r6 = r6 >> numDefine2;
                r7 = r7 >> numDefine2;
                f8 = heapClassInst.heapFloat[r7 + numDefine3];
                f9 = heapClassInst.heapFloat[r6 + numDefine3];
                f10 = heapClassInst.heapFloat[fp + numDefineNeg4];
                f11 = heapClassInst.heapFloat[r6 + 1];
                f12 = heapClassInst.heapFloat[r7 + 1];
                f13 = heapClassInst.heapFloat[fp + numDefineNeg8];
                f14 = heapClassInst.heapFloat[r6 + numDefine2];
                f15 = heapClassInst.heapFloat[r7 + numDefine2];
                f16 = f8 * f9;
                f17 = f10 * f13;
                f18 = f0 * f3;
                f19 = f2 * f1;
                f20 = f0 * f1;
                f21 = f2 * f3;
                f22 = f8 * f13;
                f23 = f10 * f9;
                f24 = f8 * f11;
                f25 = f12 * f9;
                f26 = f0 * f5;
                f27 = f4 * f1;
                f16 = f16 - f17;
                f17 = f12 * f11;
                f18 = f18 + f19;
                f19 = f4 * f7;
                f20 = f20 - f21;
                f21 = f4 * f5;
                f22 = f22 + f23;
                f23 = f12 * f14;
                f0 = f0 * f7;
                f1 = f6 * f1;
                f24 = f24 + f25;
                f25 = f15 * f13;
                f26 = f26 + f27;
                f27 = f6 * f3;
                f8 = f8 * f14;
                f9 = f15 * f9;
                f16 = f16 - f17;
                f17 = f15 * f14;
                f18 = f18 + f19;
                f19 = f6 * f5;
                f20 = f20 - f21;
                f6 = f6 * f7;
                f21 = f22 + f23;
                f15 = f15 * f11;
                f0 = f0 + f1;
                f1 = f2 * f5;
                f5 = f24 + f25;
                f14 = f10 * f14;
                f22 = f26 + f27;
                f2 = f2 * f7;
                f7 = f8 + f9;
                f8 = f10 * f11;
                f9 = f21 - f15;
                heapClassInst.heapFloat[fp + numDefineNeg46] = f9;
                f10 = f18 - f19;
                heapClassInst.heapFloat[fp + numDefineNeg49] = f10;
                f5 = f5 - f14;
                heapClassInst.heapFloat[fp + numDefineNeg45] = f5;
                f6 = f20 - f6;
                heapClassInst.heapFloat[fp + numDefineNeg52] = f6;
                f11 = f16 - f17;
                heapClassInst.heapFloat[fp + numDefineNeg48] = f11;
                f2 = f22 - f2;
                heapClassInst.heapFloat[fp + numDefineNeg50] = f2;
                f0 = f0 + f1;
                f1 = f4 * f3;
                f3 = f7 + f8;
                f4 = f12 * f13;
                f3 = f3 - f4;
                heapClassInst.heapFloat[fp + numDefineNeg47] = f3;
                f0 = f0 - f1;
                heapClassInst.heapFloat[fp + numDefineNeg51] = f0;
                f1 = f11 * f2;
                f4 = f6 * f5;
                f7 = f11 * f6;
                f8 = f10 * f9;
                f12 = f11 * f10;
                f13 = f6 * f9;
                f1 = f1 - f4;
                f4 = f10 * f3;
                f7 = f7 + f8;
                f8 = f2 * f5;
                f11 = f11 * f0;
                f6 = f6 * f3;
                f12 = f12 - f13;
                f13 = f0 * f5;
                f1 = f1 - f4;
                f4 = f0 * f9;
                f7 = f7 + f8;
                f0 = f0 * f3;
                f6 = f11 - f6;
                f8 = f2 * f9;
                f11 = f12 - f13;
                f2 = f2 * f3;
                f2 = f11 + f2;
                f1 = f1 + f4;
                f4 = 0;
                f0 = f7 + f0;
                f6 = f6 - f8;
                f7 = f10 * f5;
                f6 = f6 + f7;
                f7 = f1 * f4;
                f8 = -f2;
                f10 = f0 * f4;
                f11 = f2 * f4;
                f12 = f10 + f6;
                f8 = f8 - f7;
                f13 = f6 * f4;
                f7 = f0 + f7;
                f8 = f8 - f13;
                f7 = f7 - f13;
                f12 = f12 - f11;
                f10 = f10 + f11;
                f10 = f10 - f1;
                f11 = f7 * f0;
                f13 = f8 * f2;
                f14 = f12 * f0;
                f15 = f8 * f1;
                f11 = f11 - f13;
                f13 = f12 * f6;
                f14 = f14 - f15;
                f15 = f10 * f2;
                f16 = f10 * f0;
                f8 = f8 * f6;
                f11 = f11 - f13;
                f10 = f10 * f1;
                f13 = f14 - f15;
                f14 = f7 * f6;
                f8 = f16 - f8;
                f7 = f7 * f1;
                f10 = f11 + f10;
                f11 = f13 + f14;
                f7 = f8 - f7;
                f8 = f12 * f2;
                f7 = f7 + f8;
                f8 = f10 * f10;
                f12 = f11 * f11;
                f8 = f8 + f12;
                f12 = f7 * f7;
                f8 = f8 + f12;
                heapClassInst.heapFloat[g0] = f8;
                f8 = 1;
                sqrtf(i7);
                f12 = (float) (f8 / commonVariable.fg0);
                f11 = f11 * f12;
                f7 = f7 * f12;
                f10 = f10 * f12;
                f12 = f11 * f4;
                f13 = f7 * f4;
                f14 = f10 + f12;
                f14 = f14 + f13;
                f3 = -f3;
                heapClassInst.heapFloat[fp + numDefineNeg43] = f3;
                f3 = -f5;
                heapClassInst.heapFloat[fp + numDefineNeg44] = f3;
                f3 = -f9;
                heapClassInst.heapFloat[fp + numDefineNeg42] = f3;
                f3 = (float) numDefineNegFloat945;
                if (f14 >= f3) {
                    f3 = f14 + f8;
                    f3 = f3 + f3;
                    heapClassInst.heapFloat[g0] = f3;
                    sqrtf(i7);
                    f10 = f10 * f4;
                    f5 = (float) numDefineFloat05;
                    f11 = f11 - f10;
                    f9 = (float) (f8 / commonVariable.fg0);
                    f7 = f10 - f7;
                    f13 = f13 - f12;
                    f12 = (float) (commonVariable.fg0 * f5);
                    f11 = f11 * f9;
                    f10 = f7 * f9;
                    f7 = f13 * f9;
                } else {
                    f7 = -0;
                    f10 = 1;
                    f11 = 0;
                    f12 = f11;
                }
                f3 = f7 * f7;
                f5 = f10 * f10;
                f3 = f3 + f5;
                f5 = f11 * f11;
                f3 = f3 + f5;
                f5 = f12 * f12;
                f3 = f3 + f5;
                heapClassInst.heapFloat[g0] = f3;
                sqrtf(i7);
                f3 = (float) commonVariable.fg0;
                if (f3 != f4) {
                    f3 = f8 / f3;
                    f5 = f12 * f3;
                    f7 = f7 * f3;
                    f9 = f10 * f3;
                    f3 = f11 * f3;
                    f10 = f5 * f1;
                    f11 = f0 * f9;
                    f12 = f5 * f2;
                    f13 = f0 * f7;
                    f14 = f5 * f6;
                    f15 = f0 * f3;
                    f10 = f10 - f11;
                    f11 = f2 * f3;
                    f12 = f12 - f13;
                    f13 = f6 * f9;
                    f0 = f5 * f0;
                    f16 = f2 * f7;
                    f14 = f14 - f15;
                    f15 = f1 * f7;
                    f10 = f10 - f11;
                    f11 = f6 * f7;
                    f12 = f12 - f13;
                    f13 = f1 * f3;
                    f10 = f10 + f11;
                    f11 = f12 + f13;
                    f0 = f0 + f16;
                    f1 = f1 * f9;
                    f12 = f14 - f15;
                    f2 = f2 * f9;
                    f2 = f12 + f2;
                    f12 = f11 * f11;
                    f13 = f10 * f10;
                    f0 = f0 + f1;
                    f1 = f6 * f3;
                    f0 = f0 + f1;
                    f1 = f12 + f13;
                    f6 = f2 * f2;
                    f1 = f1 + f6;
                    f6 = f0 * f0;
                    f1 = f1 + f6;
                    heapClassInst.heapFloat[g0] = f1;
                    sqrtf(i7);
                    f1 = (float) commonVariable.fg0;
                    if (f1 != f4) {
                        f1 = f8 / f1;
                        f6 = heapClassInst.heapFloat[r1 + numDefine108];
                        heapClassInst.heapFloat[fp + numDefineNeg40] = f6;
                        f12 = heapClassInst.heapFloat[r1 + numDefine111];
                        f11 = f11 * f1;
                        heapClassInst.heapFloat[fp + numDefineNeg37] = f11;
                        f10 = f10 * f1;
                        heapClassInst.heapFloat[fp + numDefineNeg38] = f10;
                        f2 = f2 * f1;
                        heapClassInst.heapFloat[fp + numDefineNeg39] = f2;
                        f0 = f0 * f1;
                        heapClassInst.heapFloat[fp + numDefineNeg41] = f0;
                        if (f6 < f12) {
                            label = numDefine27;
                        } else {
                            f0 = heapClassInst.heapFloat[r1 + numDefine109];
                            if (f0 < f12) {
                                label = numDefine27;
                            } else {
                                f12 = -1;
                                f12 = f5 < f12 ? f12 : f5;
                                f12 = f12 > f8 ? f8 : f12;
                                heapClassInst.heapFloat[g0] = f12;
                                acosf(i7);
                                f12 = (float) (commonVariable.fg0 + commonVariable.fg0);
                                f0 = (float) numDefineFloat1257;
                                if (f12 > f0) {
                                    f4 = f7 * f7;
                                    f0 = f9 * f9;
                                    f4 = f4 + f0;
                                    f0 = f3 * f3;
                                    f4 = f4 + f0;
                                    heapClassInst.heapFloat[g0] = f4;
                                    f4 = 1;
                                    sqrtf(i7);
                                    f0 = (float) (f4 / commonVariable.fg0);
                                    f1 = f9 * f0;
                                    f2 = f7 * f0;
                                    f0 = f3 * f0;
                                    f3 = f1;
                                    f3 = Math.abs(f3);
                                    f5 = (float) numDefineFloat1257;
                                    if (f3 > f5) {
                                        f3 = heapClassInst.heapFloat[r1 + numDefine109];
                                        f5 = heapClassInst.heapFloat[r1 + numDefine108];
                                        f6 = f0 * f0;
                                        f7 = f1 * f1;
                                        f6 = f6 / f7;
                                        f5 = f5 * f5;
                                        f3 = f3 * f3;
                                        f5 = f6 / f5;
                                        f3 = f4 / f3;
                                        f4 = f6 + f4;
                                        f3 = f5 + f3;
                                        f4 = f4 / f3;
                                        heapClassInst.heapFloat[g0] = f4;
                                        sqrtf(i7);
                                        f4 = (float) commonVariable.fg0;
                                    } else {
                                        f4 = heapClassInst.heapFloat[r1 + numDefine108];
                                    }
                                }
                                f3 = heapClassInst.heapFloat[r1 + numDefine104];
                                f5 = f3 * f4;
                                if (f5 >= f12) {
                                    label = numDefine58;
                                } else {
                                    r3 = 1;
                                    heapClassInst.heap8[r0 + numDefine514] = (byte) r3;
                                    if (!(f12 >= f4)) {
                                        f6 = (float) numDefineFloat945;
                                        if (f3 < f6) {
                                            f8 = f12 - f5;
                                            f3 = f4 - f5;
                                            f8 = f8 / f3;
                                        }
                                    }
                                    f12 = f12 - f5;
                                    heapClassInst.heapFloat[r1 + numDefine129] = f8;
                                    f3 = f1;
                                    heapClassInst.heapFloat[r1 + numDefine123] = f12;
                                    f12 = Math.abs(f3);
                                    f3 = (float) numDefineFloat1257;
                                    if (f12 > f3) {
                                        f0 = -f0;
                                        f12 = heapClassInst.heapFloat[r1 + numDefine109];
                                        f3 = heapClassInst.heapFloat[r1 + numDefine108];
                                        f12 = f12 / f3;
                                        f3 = f0 / f1;
                                        f12 = f12 * f3;
                                        f12 = f12 * f1;
                                        f12 = Math.abs(f12);
                                        f3 = 0;
                                        if (f0 <= f3) {
                                            f12 = -f12;
                                        }
                                        f0 = f2 * f2;
                                        f3 = f1 * f1;
                                        f0 = f0 + f3;
                                        f3 = f12 * f12;
                                        f0 = f0 + f3;
                                        heapClassInst.heapFloat[g0] = f0;
                                        f0 = 1;
                                        sqrtf(i7);
                                        f0 = (float) (f0 / commonVariable.fg0);
                                        f12 = -f12;
                                        f2 = f2 * f0;
                                        f1 = f1 * f0;
                                        f0 = f0 * f12;
                                    }
                                    f12 = -f2;
                                    f3 = -f1;
                                    f4 = heapClassInst.heapFloat[fp + numDefineNeg46];
                                    f5 = f2 * f4;
                                    f6 = heapClassInst.heapFloat[fp + numDefineNeg45];
                                    f7 = f6 * f1;
                                    f8 = heapClassInst.heapFloat[fp + numDefineNeg48];
                                    f12 = f8 * f12;
                                    f9 = f6 * f0;
                                    f10 = -f0;
                                    f5 = f5 + f7;
                                    f7 = heapClassInst.heapFloat[fp + numDefineNeg47];
                                    f11 = f7 * f0;
                                    f12 = f12 - f9;
                                    f9 = f7 * f1;
                                    f3 = f8 * f3;
                                    f7 = f7 * f2;
                                    f12 = f12 + f9;
                                    f5 = f5 + f11;
                                    f3 = f3 - f7;
                                    f0 = f4 * f0;
                                    f7 = f8 * f10;
                                    f1 = f4 * f1;
                                    f0 = f3 + f0;
                                    f3 = heapClassInst.heapFloat[fp + numDefineNeg42];
                                    f4 = f5 * f3;
                                    f9 = f12 * f8;
                                    f1 = f7 - f1;
                                    f2 = f6 * f2;
                                    f1 = f1 + f2;
                                    f2 = heapClassInst.heapFloat[fp + numDefineNeg44];
                                    f6 = f5 * f2;
                                    f7 = f0 * f8;
                                    f4 = f4 + f9;
                                    f9 = heapClassInst.heapFloat[fp + numDefineNeg43];
                                    f10 = f0 * f9;
                                    f5 = f5 * f9;
                                    f8 = f1 * f8;
                                    f6 = f6 + f7;
                                    f7 = f1 * f3;
                                    f4 = f4 + f10;
                                    f1 = f1 * f2;
                                    f1 = f4 - f1;
                                    f4 = f5 + f8;
                                    f2 = f12 * f2;
                                    f5 = f6 + f7;
                                    f12 = f12 * f9;
                                    f2 = f4 + f2;
                                    f0 = f0 * f3;
                                    f12 = f5 - f12;
                                    heapClassInst.heapFloat[r1 + numDefine112] = f1;
                                    f0 = f2 - f0;
                                    heapClassInst.heapFloat[r1 + numDefine113] = f12;
                                    heapClassInst.heapFloat[r1 + numDefine114] = f0;
                                    heapClassInst.heap32[r1 + numDefine115] = 0;
                                    heapClassInst.heap32[r1 + numDefine131] = 0;
                                    heapClassInst.heap32[r1 + numDefine132] = 0;
                                    heapClassInst.heap32[r1 + numDefine133] = 0;
                                    r3 = r2 >> numDefine2;
                                    heapClassInst.heap32[r1 + numDefine134] = 0;
                                    r4 = r5 >> numDefine2;
                                    f2 = heapClassInst.heapFloat[r3 + 1];
                                    f3 = heapClassInst.heapFloat[r3 + numDefine5];
                                    f4 = heapClassInst.heapFloat[r3];
                                    f5 = heapClassInst.heapFloat[r3 + numDefine4];
                                    f6 = heapClassInst.heapFloat[r4 + 1];
                                    f7 = heapClassInst.heapFloat[r4 + numDefine5];
                                    f8 = heapClassInst.heapFloat[r4];
                                    f9 = heapClassInst.heapFloat[r4 + numDefine4];
                                    f10 = heapClassInst.heapFloat[r3 + numDefine2];
                                    f11 = heapClassInst.heapFloat[r3 + numDefine6];
                                    f13 = heapClassInst.heapFloat[r3 + numDefine9];
                                    f14 = heapClassInst.heapFloat[r3 + numDefine8];
                                    f15 = heapClassInst.heapFloat[r4 + numDefine2];
                                    f16 = heapClassInst.heapFloat[r4 + numDefine6];
                                    f17 = heapClassInst.heapFloat[r4 + numDefine9];
                                    f18 = heapClassInst.heapFloat[r4 + numDefine8];
                                    f4 = f4 * f1;
                                    f5 = f5 * f12;
                                    f2 = f2 * f1;
                                    f3 = f3 * f12;
                                    f8 = f8 * f1;
                                    f9 = f9 * f12;
                                    f6 = f6 * f1;
                                    f7 = f7 * f12;
                                    f19 = heapClassInst.heapFloat[r3 + numDefine10];
                                    f20 = heapClassInst.heapFloat[r4 + numDefine10];
                                    f4 = f4 + f5;
                                    f5 = f14 * f0;
                                    f2 = f2 + f3;
                                    f3 = f13 * f0;
                                    f10 = f10 * f1;
                                    f11 = f11 * f12;
                                    f8 = f8 + f9;
                                    f9 = f18 * f0;
                                    f6 = f6 + f7;
                                    f7 = f17 * f0;
                                    f13 = f15 * f1;
                                    f14 = f16 * f12;
                                    f4 = f4 + f5;
                                    f2 = f2 + f3;
                                    f3 = f8 + f9;
                                    f5 = f6 + f7;
                                    f6 = f10 + f11;
                                    f7 = f19 * f0;
                                    f8 = f13 + f14;
                                    f9 = f20 * f0;
                                    f6 = f6 + f7;
                                    f7 = f8 + f9;
                                    f4 = f1 * f4;
                                    f2 = f12 * f2;
                                    f1 = f1 * f3;
                                    f12 = f12 * f5;
                                    f2 = f4 + f2;
                                    f3 = f0 * f6;
                                    f12 = f1 + f12;
                                    f0 = f0 * f7;
                                    f1 = f2 + f3;
                                    f12 = f12 + f0;
                                    f0 = 1;
                                    f12 = f1 + f12;
                                    f12 = f0 / f12;
                                    heapClassInst.heapFloat[r1 + numDefine120] = f12;
                                    label = numDefine58;
                                }
                            }
                        }
                        repeat37: do {
                            if (label == numDefine27) {
                                r4 = r4 >> numDefine2;
                                r3 = r3 >> numDefine2;
                                f0 = heapClassInst.heapFloat[r1 + numDefine72];
                                f1 = heapClassInst.heapFloat[r3];
                                f2 = heapClassInst.heapFloat[r1 + numDefine73];
                                f3 = heapClassInst.heapFloat[r3 + numDefine4];
                                f4 = heapClassInst.heapFloat[r1 + numDefine74];
                                f5 = heapClassInst.heapFloat[r1 + numDefine76];
                                f6 = heapClassInst.heapFloat[r3 + 1];
                                f7 = heapClassInst.heapFloat[r1 + numDefine77];
                                f8 = heapClassInst.heapFloat[r3 + numDefine5];
                                f9 = heapClassInst.heapFloat[r1 + numDefine78];
                                f10 = heapClassInst.heapFloat[r4];
                                f11 = heapClassInst.heapFloat[r1 + numDefine88];
                                f13 = heapClassInst.heapFloat[r4 + numDefine4];
                                heapClassInst.heapFloat[fp + numDefineNeg55] = f13;
                                f14 = heapClassInst.heapFloat[r4 + 1];
                                f15 = heapClassInst.heapFloat[r1 + numDefine92];
                                f13 = heapClassInst.heapFloat[r4 + numDefine5];
                                heapClassInst.heapFloat[fp + numDefineNeg56] = f13;
                                f16 = heapClassInst.heapFloat[r3 + numDefine8];
                                f17 = heapClassInst.heapFloat[r3 + numDefine9];
                                f18 = heapClassInst.heapFloat[r4 + numDefine8];
                                heapClassInst.heapFloat[fp + numDefineNeg53] = f18;
                                f19 = heapClassInst.heapFloat[r4 + numDefine9];
                                heapClassInst.heapFloat[fp + numDefineNeg54] = f19;
                                f13 = f1 * f0;
                                heapClassInst.heapFloat[fp + numDefineNeg57] = f13;
                                f13 = f6 * f5;
                                heapClassInst.heapFloat[fp + numDefineNeg61] = f13;
                                f18 = f3 * f0;
                                heapClassInst.heapFloat[fp + numDefineNeg59] = f18;
                                f13 = f8 * f5;
                                heapClassInst.heapFloat[fp + numDefineNeg62] = f13;
                                f18 = heapClassInst.heapFloat[r1 + numDefine80];
                                f19 = heapClassInst.heapFloat[r3 + numDefine2];
                                f20 = heapClassInst.heapFloat[r1 + numDefine81];
                                f21 = heapClassInst.heapFloat[r3 + numDefine6];
                                f22 = heapClassInst.heapFloat[r1 + numDefine82];
                                f23 = f1 * f2;
                                f24 = f6 * f7;
                                f25 = f3 * f2;
                                f26 = f8 * f7;
                                f10 = f10 * f11;
                                heapClassInst.heapFloat[fp + numDefineNeg60] = f10;
                                f10 = f14 * f15;
                                heapClassInst.heapFloat[fp + numDefineNeg63] = f10;
                                f10 = heapClassInst.heapFloat[r4 + numDefine2];
                                heapClassInst.heapFloat[fp + numDefineNeg64] = f10;
                                f13 = heapClassInst.heapFloat[r1 + numDefine96];
                                f14 = heapClassInst.heapFloat[r4 + numDefine6];
                                heapClassInst.heapFloat[fp + numDefineNeg58] = f14;
                                f1 = f1 * f4;
                                f6 = f6 * f9;
                                f27 = heapClassInst.heapFloat[fp + numDefineNeg55];
                                f27 = f27 * f11;
                                f28 = heapClassInst.heapFloat[fp + numDefineNeg56];
                                f28 = f28 * f15;
                                f3 = f3 * f4;
                                f8 = f8 * f9;
                                f29 = heapClassInst.heapFloat[r3 + numDefine10];
                                f30 = heapClassInst.heapFloat[r4 + numDefine10];
                                heapClassInst.heapFloat[fp + numDefineNeg55] = f30;
                                f10 = heapClassInst.heapFloat[fp + numDefineNeg57];
                                f14 = heapClassInst.heapFloat[fp + numDefineNeg61];
                                f10 = f10 + f14;
                                heapClassInst.heapFloat[fp + numDefineNeg56] = f10;
                                f14 = f19 * f18;
                                f10 = heapClassInst.heapFloat[fp + numDefineNeg59];
                                f30 = heapClassInst.heapFloat[fp + numDefineNeg62];
                                f10 = f10 + f30;
                                f30 = f21 * f18;
                                f0 = f16 * f0;
                                heapClassInst.heapFloat[fp + numDefineNeg57] = f0;
                                f0 = f17 * f5;
                                heapClassInst.heapFloat[fp + numDefineNeg59] = f0;
                                f5 = f23 + f24;
                                f23 = f19 * f20;
                                f24 = f25 + f26;
                                f25 = f21 * f20;
                                f2 = f16 * f2;
                                f7 = f17 * f7;
                                f26 = heapClassInst.heapFloat[fp + numDefineNeg60];
                                f0 = heapClassInst.heapFloat[fp + numDefineNeg63];
                                f0 = f26 + f0;
                                f26 = heapClassInst.heapFloat[fp + numDefineNeg64];
                                f26 = f26 * f13;
                                f1 = f1 + f6;
                                f6 = f19 * f22;
                                f19 = f27 + f28;
                                f27 = heapClassInst.heapFloat[fp + numDefineNeg58];
                                f27 = f27 * f13;
                                f3 = f3 + f8;
                                f8 = f21 * f22;
                                f21 = heapClassInst.heapFloat[fp + numDefineNeg53];
                                f11 = f21 * f11;
                                f21 = heapClassInst.heapFloat[fp + numDefineNeg54];
                                f15 = f21 * f15;
                                f4 = f16 * f4;
                                f9 = f17 * f9;
                                f16 = heapClassInst.heapFloat[fp + numDefineNeg56];
                                f14 = f16 + f14;
                                f0 = f0 + f26;
                                f5 = f5 + f23;
                                f1 = f1 + f6;
                                f6 = f10 + f30;
                                f10 = f19 + f27;
                                f16 = f24 + f25;
                                f3 = f3 + f8;
                                f8 = heapClassInst.heapFloat[fp + numDefineNeg57];
                                f17 = heapClassInst.heapFloat[fp + numDefineNeg59];
                                f8 = f8 + f17;
                                f17 = f29 * f18;
                                f2 = f2 + f7;
                                f7 = f29 * f20;
                                f11 = f11 + f15;
                                f30 = heapClassInst.heapFloat[fp + numDefineNeg55];
                                f13 = f30 * f13;
                                f4 = f4 + f9;
                                f9 = f29 * f22;
                                f8 = f8 + f17;
                                f11 = f11 + f13;
                                f2 = f2 + f7;
                                f4 = f4 + f9;
                                f7 = f0 * f5;
                                f9 = f10 * f16;
                                f13 = f0 * f1;
                                f15 = f10 * f3;
                                f7 = f7 + f9;
                                f9 = f11 * f2;
                                f13 = f13 + f15;
                                f15 = f11 * f4;
                                f7 = f7 + f9;
                                f9 = f13 + f15;
                                f13 = heapClassInst.heapFloat[fp + numDefineNeg40];
                                if (!(f13 >= f12)) {
                                    f13 = heapClassInst.heapFloat[r1 + numDefine109];
                                    if (!(f13 >= f12)) {
                                        f1 = 0;
                                        if (f7 < f1) {
                                            f7 = -f7;
                                        }
                                        f2 = (float) numDefineFloat1257;
                                        if (!(f7 >= f2)) {
                                            if (f9 < f1) {
                                                f9 = -f9;
                                            }
                                            if (f9 < f2) {
                                                break repeat37;
                                            }
                                        }
                                        f1 = f10 * f8;
                                        f2 = f11 * f6;
                                        f1 = f1 - f2;
                                        r3 = 1;
                                        f2 = f11 * f14;
                                        f3 = f0 * f8;
                                        f2 = f2 - f3;
                                        f0 = f0 * f6;
                                        f3 = f10 * f14;
                                        f1 = -f1;
                                        heapClassInst.heap8[r0 + numDefine514] = (byte) r3;
                                        f0 = f0 - f3;
                                        f2 = -f2;
                                        heapClassInst.heapFloat[r1 + numDefine112] = f1;
                                        f0 = -f0;
                                        heapClassInst.heapFloat[r1 + numDefine113] = f2;
                                        heapClassInst.heapFloat[r1 + numDefine114] = f0;
                                        heapClassInst.heap32[r1 + numDefine115] = 0;
                                        break repeat37;
                                    }
                                }
                                f13 = f0 * f14;
                                f15 = f10 * f6;
                                f13 = f13 + f15;
                                f15 = f11 * f8;
                                f13 = f13 + f15;
                                f15 = heapClassInst.heapFloat[fp + numDefineNeg40];
                                repeat52: do {
                                    if (f15 >= f12) {
                                        f15 = 0;
                                        if (f9 < f15) {
                                            f17 = -f9;
                                        } else {
                                            f17 = f9;
                                        }
                                        f18 = (float) numDefineFloat1257;
                                        if (f17 < f18) {
                                            break repeat52;
                                        } else {
                                            r3 = 1;
                                            heapClassInst.heap8[r0 + numDefine514] = (byte) r3;
                                            f17 = heapClassInst.heapFloat[fp + numDefineNeg40];
                                            if (f17 < f12) {
                                                break repeat52;
                                            } else {
                                                heapClassInst.heapFloat[g0] = f7;
                                                heapClassInst.heapFloat[g0 + 1] = f13;
                                                atan2f(i7);
                                                f9 = (float) commonVariable.fg0;
                                                f12 = heapClassInst.heapFloat[r1 + numDefine108];
                                                if (f12 >= f9) {
                                                    f17 = -f12;
                                                    if (f9 < f17) {
                                                        heapClassInst.heapFloat[g0] = f12;
                                                        cosf(i7);
                                                        f13 = (float) commonVariable.fg0;
                                                        f7 = heapClassInst.heapFloat[r1 + numDefine108];
                                                        heapClassInst.heapFloat[g0] = f7;
                                                        sinf(i7);
                                                        f7 = (float) -commonVariable.fg0;
                                                        f9 = 0;
                                                    } else {
                                                        f9 = f15;
                                                    }
                                                } else {
                                                    heapClassInst.heapFloat[g0] = f12;
                                                    cosf(i7);
                                                    f13 = (float) commonVariable.fg0;
                                                    f9 = heapClassInst.heapFloat[r1 + numDefine108];
                                                    heapClassInst.heapFloat[g0] = f9;
                                                    f9 = 0;
                                                    sinf(i7);
                                                    f7 = (float) commonVariable.fg0;
                                                }
                                            }
                                        }
                                    } else {
                                        f15 = 0;
                                        if (f7 < f15) {
                                            f17 = -f7;
                                        } else {
                                            f17 = f7;
                                        }
                                        f18 = (float) numDefineFloat1257;
                                        if (f17 >= f18) {
                                            r3 = 1;
                                            heapClassInst.heap8[r0 + numDefine514] = (byte) r3;
                                            f17 = heapClassInst.heapFloat[r1 + numDefine109];
                                            if (!(f17 < f12)) {
                                                heapClassInst.heapFloat[g0] = f9;
                                                heapClassInst.heapFloat[g0 + 1] = f13;
                                                atan2f(i7);
                                                f7 = (float) commonVariable.fg0;
                                                f12 = heapClassInst.heapFloat[r1 + numDefine109];
                                                if (f12 >= f7) {
                                                    f17 = -f12;
                                                    if (f7 < f17) {
                                                        heapClassInst.heapFloat[g0] = f12;
                                                        cosf(i7);
                                                        f13 = (float) commonVariable.fg0;
                                                        f7 = heapClassInst.heapFloat[r1 + numDefine109];
                                                        heapClassInst.heapFloat[g0] = f7;
                                                        sinf(i7);
                                                        f9 = (float) -commonVariable.fg0;
                                                        f7 = 0;
                                                    } else {
                                                        f7 = f15;
                                                    }
                                                } else {
                                                    heapClassInst.heapFloat[g0] = f12;
                                                    cosf(i7);
                                                    f13 = (float) commonVariable.fg0;
                                                    f7 = heapClassInst.heapFloat[r1 + numDefine109];
                                                    heapClassInst.heapFloat[g0] = f7;
                                                    f7 = 0;
                                                    sinf(i7);
                                                    f9 = (float) commonVariable.fg0;
                                                }
                                            }
                                        }
                                    }
                                } while (false);
                                f12 = f14 * f13;
                                f5 = f5 * f7;
                                f6 = f6 * f13;
                                f14 = f16 * f7;
                                f5 = f12 + f5;
                                f1 = f1 * f9;
                                f6 = f6 + f14;
                                f3 = f3 * f9;
                                f8 = f8 * f13;
                                f2 = f2 * f7;
                                f1 = f5 + f1;
                                f3 = f6 + f3;
                                f2 = f8 + f2;
                                f4 = f4 * f9;
                                f2 = f2 + f4;
                                f4 = f1 * f1;
                                f5 = f3 * f3;
                                f4 = f4 + f5;
                                f5 = f2 * f2;
                                f4 = f4 + f5;
                                heapClassInst.heapFloat[g0] = f4;
                                f4 = 1;
                                sqrtf(i7);
                                f5 = (float) (f4 / commonVariable.fg0);
                                f2 = f2 * f5;
                                f3 = f3 * f5;
                                f1 = f1 * f5;
                                f5 = f10 * f2;
                                f6 = f11 * f3;
                                f5 = f5 - f6;
                                f6 = f11 * f1;
                                f2 = f0 * f2;
                                f2 = f6 - f2;
                                f6 = -f5;
                                f0 = f0 * f3;
                                f1 = f10 * f1;
                                f0 = f0 - f1;
                                f1 = -f2;
                                heapClassInst.heapFloat[r1 + numDefine112] = f6;
                                f3 = -f0;
                                heapClassInst.heapFloat[r1 + numDefine113] = f1;
                                heapClassInst.heapFloat[r1 + numDefine114] = f3;
                                heapClassInst.heap32[r1 + numDefine115] = 0;
                                f1 = f5 * f5;
                                f2 = f2 * f2;
                                f1 = f1 + f2;
                                f0 = f0 * f0;
                                f0 = f1 + f0;
                                heapClassInst.heapFloat[g0] = f0;
                                sqrtf(i7);
                                heapClassInst.heapFloat[r1 + numDefine123] = (float) commonVariable.fg0;
                                f0 = heapClassInst.heapFloat[r1 + numDefine112];
                                f1 = heapClassInst.heapFloat[r1 + numDefine113];
                                f2 = heapClassInst.heapFloat[r1 + numDefine114];
                                f0 = f0 * f0;
                                f1 = f1 * f1;
                                f0 = f0 + f1;
                                f1 = f2 * f2;
                                f0 = f0 + f1;
                                heapClassInst.heapFloat[g0] = f0;
                                sqrtf(i7);
                                f0 = (float) (f4 / commonVariable.fg0);
                                f1 = heapClassInst.heapFloat[r1 + numDefine112];
                                f1 = f1 * f0;
                                heapClassInst.heapFloat[r1 + numDefine112] = f1;
                                f1 = heapClassInst.heapFloat[r1 + numDefine113];
                                f1 = f1 * f0;
                                heapClassInst.heapFloat[r1 + numDefine113] = f1;
                                f1 = heapClassInst.heapFloat[r1 + numDefine114];
                                f0 = f1 * f0;
                                heapClassInst.heapFloat[r1 + numDefine114] = f0;
                            }
                        } while (false);
                        f0 = heapClassInst.heapFloat[r1 + numDefine110];
                        f1 = 0;
                        if (f0 < f1) {
                            heapClassInst.heap32[r1 + numDefine125] = 0;
                            break repeat8;
                        } else {
                            f0 = -1;
                            f1 = heapClassInst.heapFloat[fp + numDefineNeg41];
                            f1 = f1 < f0 ? f0 : f1;
                            f2 = 1;
                            f1 = f1 > f2 ? f2 : f1;
                            heapClassInst.heapFloat[g0] = f1;
                            acosf(i7);
                            f1 = (float) (commonVariable.fg0 + commonVariable.fg0);
                            heapClassInst.heapFloat[r1 + numDefine125] = f1;
                            f3 = (float) numDefineFloat132;
                            if (f1 > f3) {
                                f1 = heapClassInst.heapFloat[fp + numDefineNeg41];
                                f1 = -f1;
                                f1 = f1 < f0 ? f0 : f1;
                                f0 = 1;
                                f1 = f1 > f0 ? f0 : f1;
                                heapClassInst.heapFloat[g0] = f1;
                                acosf(i7);
                                f0 = heapClassInst.heapFloat[fp + numDefineNeg39];
                                f0 = -f0;
                                heapClassInst.heapFloat[fp + numDefineNeg39] = f0;
                                f0 = heapClassInst.heapFloat[fp + numDefineNeg38];
                                f0 = -f0;
                                heapClassInst.heapFloat[fp + numDefineNeg38] = f0;
                                f0 = heapClassInst.heapFloat[fp + numDefineNeg37];
                                f0 = -f0;
                                heapClassInst.heapFloat[fp + numDefineNeg37] = f0;
                                f1 = (float) (commonVariable.fg0 + commonVariable.fg0);
                                heapClassInst.heapFloat[r1 + numDefine125] = f1;
                            }
                            f0 = (float) numDefineFloat1257;
                            if (f1 > f0) {
                                f1 = heapClassInst.heapFloat[fp + numDefineNeg37];
                                f0 = f1 * f1;
                                f3 = heapClassInst.heapFloat[fp + numDefineNeg38];
                                f4 = f3 * f3;
                                f0 = f0 + f4;
                                f4 = heapClassInst.heapFloat[fp + numDefineNeg39];
                                f5 = f4 * f4;
                                f0 = f0 + f5;
                                heapClassInst.heapFloat[g0] = f0;
                                f0 = 1;
                                sqrtf(i7);
                                f0 = (float) (f0 / commonVariable.fg0);
                                f1 = f1 * f0;
                                heapClassInst.heapFloat[fp + numDefineNeg37] = f1;
                                f3 = f3 * f0;
                                heapClassInst.heapFloat[fp + numDefineNeg38] = f3;
                                f4 = f4 * f0;
                                heapClassInst.heapFloat[fp + numDefineNeg39] = f4;
                                f1 = heapClassInst.heapFloat[r1 + numDefine125];
                            }
                            f0 = heapClassInst.heapFloat[r1 + numDefine110];
                            f3 = heapClassInst.heapFloat[r1 + numDefine104];
                            f4 = f0 * f3;
                            if (!(f1 <= f4)) {
                                r3 = 1;
                                heapClassInst.heap8[r0 + numDefine513] = (byte) r3;
                                if (f1 >= f0) {
                                    label = numDefine66;
                                } else {
                                    f5 = (float) numDefineFloat945;
                                    if (f3 < f5) {
                                        f3 = f1 - f4;
                                        f0 = f0 - f4;
                                        f0 = f3 / f0;
                                        label = numDefine68;
                                    } else {
                                        label = numDefine66;
                                    }
                                }
                                if (label == numDefine66) {
                                    f0 = f2;
                                }
                                f3 = heapClassInst.heapFloat[fp + numDefineNeg37];
                                f5 = -f3;
                                f6 = heapClassInst.heapFloat[fp + numDefineNeg38];
                                f7 = -f6;
                                f8 = heapClassInst.heapFloat[fp + numDefineNeg46];
                                f9 = f3 * f8;
                                f10 = heapClassInst.heapFloat[fp + numDefineNeg45];
                                f11 = f10 * f6;
                                f12 = heapClassInst.heapFloat[fp + numDefineNeg48];
                                f5 = f12 * f5;
                                f13 = heapClassInst.heapFloat[fp + numDefineNeg39];
                                f14 = f10 * f13;
                                f15 = -f13;
                                f9 = f9 + f11;
                                f11 = heapClassInst.heapFloat[fp + numDefineNeg47];
                                f16 = f11 * f13;
                                f5 = f5 - f14;
                                f14 = f11 * f6;
                                f7 = f12 * f7;
                                f11 = f11 * f3;
                                f5 = f5 + f14;
                                f9 = f9 + f16;
                                f7 = f7 - f11;
                                f11 = f8 * f13;
                                f13 = f12 * f15;
                                f6 = f8 * f6;
                                f7 = f7 + f11;
                                f8 = heapClassInst.heapFloat[fp + numDefineNeg42];
                                f11 = f9 * f8;
                                f14 = f5 * f12;
                                f6 = f13 - f6;
                                f3 = f10 * f3;
                                f3 = f6 + f3;
                                f6 = heapClassInst.heapFloat[fp + numDefineNeg44];
                                f10 = f9 * f6;
                                f13 = f7 * f12;
                                f11 = f11 + f14;
                                f14 = heapClassInst.heapFloat[fp + numDefineNeg43];
                                f15 = f7 * f14;
                                f9 = f9 * f14;
                                f12 = f3 * f12;
                                f10 = f10 + f13;
                                f13 = f3 * f8;
                                f11 = f11 + f15;
                                f3 = f3 * f6;
                                f1 = f1 - f4;
                                heapClassInst.heapFloat[r1 + numDefine130] = f0;
                                f0 = f9 + f12;
                                f4 = f5 * f6;
                                f6 = f10 + f13;
                                f5 = f5 * f14;
                                f3 = f11 - f3;
                                heapClassInst.heapFloat[r1 + numDefine124] = f1;
                                f0 = f0 + f4;
                                f1 = f7 * f8;
                                f4 = f6 - f5;
                                heapClassInst.heapFloat[r1 + numDefine116] = f3;
                                f0 = f0 - f1;
                                heapClassInst.heapFloat[r1 + numDefine117] = f4;
                                heapClassInst.heapFloat[r1 + numDefine118] = f0;
                                r2 = r2 >> numDefine2;
                                heapClassInst.heap32[r1 + numDefine119] = 0;
                                r3 = r5 >> numDefine2;
                                f1 = heapClassInst.heapFloat[r2 + 1];
                                f5 = heapClassInst.heapFloat[r2 + numDefine5];
                                f6 = heapClassInst.heapFloat[r2];
                                f7 = heapClassInst.heapFloat[r2 + numDefine4];
                                f8 = heapClassInst.heapFloat[r3 + 1];
                                f9 = heapClassInst.heapFloat[r3 + numDefine5];
                                f10 = heapClassInst.heapFloat[r3];
                                f11 = heapClassInst.heapFloat[r3 + numDefine4];
                                f12 = heapClassInst.heapFloat[r2 + numDefine2];
                                f13 = heapClassInst.heapFloat[r2 + numDefine6];
                                f14 = heapClassInst.heapFloat[r2 + numDefine9];
                                f15 = heapClassInst.heapFloat[r2 + numDefine8];
                                f16 = heapClassInst.heapFloat[r3 + numDefine2];
                                f17 = heapClassInst.heapFloat[r3 + numDefine6];
                                f18 = heapClassInst.heapFloat[r3 + numDefine9];
                                f19 = heapClassInst.heapFloat[r3 + numDefine8];
                                f6 = f6 * f3;
                                f7 = f7 * f4;
                                f1 = f1 * f3;
                                f5 = f5 * f4;
                                f10 = f10 * f3;
                                f11 = f11 * f4;
                                f8 = f8 * f3;
                                f9 = f9 * f4;
                                f20 = heapClassInst.heapFloat[r2 + numDefine10];
                                f21 = heapClassInst.heapFloat[r3 + numDefine10];
                                f6 = f6 + f7;
                                f7 = f15 * f0;
                                f1 = f1 + f5;
                                f5 = f14 * f0;
                                f12 = f12 * f3;
                                f13 = f13 * f4;
                                f10 = f10 + f11;
                                f11 = f19 * f0;
                                f8 = f8 + f9;
                                f9 = f18 * f0;
                                f14 = f16 * f3;
                                f15 = f17 * f4;
                                f6 = f6 + f7;
                                f1 = f1 + f5;
                                f5 = f10 + f11;
                                f7 = f8 + f9;
                                f8 = f12 + f13;
                                f9 = f20 * f0;
                                f10 = f14 + f15;
                                f11 = f21 * f0;
                                f8 = f8 + f9;
                                f9 = f10 + f11;
                                f6 = f3 * f6;
                                f1 = f4 * f1;
                                f3 = f3 * f5;
                                f4 = f4 * f7;
                                f1 = f6 + f1;
                                f5 = f0 * f8;
                                f3 = f3 + f4;
                                f0 = f0 * f9;
                                f1 = f1 + f5;
                                f0 = f3 + f0;
                                f0 = f1 + f0;
                                f0 = f2 / f0;
                                heapClassInst.heapFloat[r1 + numDefine121] = f0;
                            }
                            r0 = heapClassInst.heapU8[r0 + numDefine514];
                            if (r0 == 0) {
                                break repeat8;
                            } else {
                                f0 = heapClassInst.heapFloat[fp + numDefineNeg37];
                                f1 = -f0;
                                f2 = heapClassInst.heapFloat[fp + numDefineNeg38];
                                f3 = -f2;
                                f4 = heapClassInst.heapFloat[fp + numDefineNeg52];
                                f1 = f4 * f1;
                                f6 = heapClassInst.heapFloat[fp + numDefineNeg39];
                                f5 = heapClassInst.heapFloat[fp + numDefineNeg50];
                                f7 = f5 * f6;
                                f8 = heapClassInst.heapFloat[fp + numDefineNeg49];
                                f9 = f0 * f8;
                                f10 = f5 * f2;
                                f11 = -f6;
                                f1 = f1 - f7;
                                f7 = heapClassInst.heapFloat[fp + numDefineNeg51];
                                f12 = f7 * f2;
                                f9 = f9 + f10;
                                f10 = f7 * f6;
                                f3 = f4 * f3;
                                f13 = f7 * f0;
                                f1 = f1 + f12;
                                f9 = f9 + f10;
                                f3 = f3 - f13;
                                f6 = f8 * f6;
                                f10 = f4 * f11;
                                f2 = f8 * f2;
                                f3 = f3 + f6;
                                f6 = f1 * f4;
                                f11 = f9 * f8;
                                f2 = f10 - f2;
                                f0 = f5 * f0;
                                f0 = f2 + f0;
                                f2 = f3 * f4;
                                f10 = f9 * f5;
                                f6 = f6 - f11;
                                f11 = f3 * f7;
                                f4 = f0 * f4;
                                f9 = f9 * f7;
                                f2 = f2 - f10;
                                f10 = f0 * f8;
                                f6 = f6 - f11;
                                f0 = f0 * f5;
                                f0 = f6 + f0;
                                f4 = f4 - f9;
                                f5 = f1 * f5;
                                f2 = f2 - f10;
                                f1 = f1 * f7;
                                f4 = f4 - f5;
                                f3 = f3 * f8;
                                f1 = f2 + f1;
                                heapClassInst.heapFloat[r1 + numDefine131] = f0;
                                f0 = f4 + f3;
                                heapClassInst.heapFloat[r1 + numDefine132] = f1;
                                heapClassInst.heapFloat[r1 + numDefine133] = f0;
                                heapClassInst.heap32[r1 + numDefine134] = 0;
                                return;
                            }
                        }
                    }
                }
                r0 = twoEStr584;
                r1 = twoEStr685;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine188;
                assertNew(i7);
            }
        } while (false);
        return;
    }

    public static void zn15btJacobianEntryC2ERK9btVector3RK11btMatrix3x3S5S2S2(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        heapClassInst.heap32[r0] = 0;
        heapClassInst.heap32[r0 + 1] = 0;
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[r0 + numDefine2] = 0;
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r0 + numDefine3] = 0;
        r2 = r2 >> numDefine2;
        f0 = heapClassInst.heapFloat[r1];
        f1 = heapClassInst.heapFloat[r2];
        f2 = heapClassInst.heapFloat[r1 + 1];
        f3 = heapClassInst.heapFloat[r2 + 1];
        f4 = heapClassInst.heapFloat[r2 + numDefine4];
        f5 = heapClassInst.heapFloat[r2 + numDefine5];
        f1 = f1 * f0;
        f3 = f3 * f2;
        f6 = heapClassInst.heapFloat[r1 + numDefine2];
        f7 = heapClassInst.heapFloat[r2 + numDefine2];
        f8 = heapClassInst.heapFloat[r2 + numDefine8];
        f9 = heapClassInst.heapFloat[r2 + numDefine9];
        f10 = heapClassInst.heapFloat[r2 + numDefine10];
        f11 = heapClassInst.heapFloat[r2 + numDefine6];
        f4 = f4 * f0;
        f5 = f5 * f2;
        f1 = f1 + f3;
        f3 = f7 * f6;
        f0 = f8 * f0;
        f2 = f9 * f2;
        f4 = f4 + f5;
        f5 = f11 * f6;
        f1 = f1 + f3;
        f0 = f0 + f2;
        f2 = f10 * f6;
        f3 = f4 + f5;
        heapClassInst.heapFloat[r0 + numDefine4] = f1;
        f0 = f0 + f2;
        heapClassInst.heapFloat[r0 + numDefine5] = f3;
        heapClassInst.heapFloat[r0 + numDefine6] = f0;
        heapClassInst.heap32[r0 + numDefine7] = 0;
        r2 = heapClassInst.heap32[fp + numDefine3];
        r2 = r2 >> numDefine2;
        f2 = heapClassInst.heapFloat[r1];
        f2 = -f2;
        f4 = heapClassInst.heapFloat[r2];
        f5 = heapClassInst.heapFloat[r1 + 1];
        f6 = heapClassInst.heapFloat[r2 + 1];
        f7 = heapClassInst.heapFloat[r2 + numDefine4];
        f8 = heapClassInst.heapFloat[r2 + numDefine5];
        f4 = f4 * f2;
        f6 = f6 * f5;
        f9 = heapClassInst.heapFloat[r1 + numDefine2];
        f10 = heapClassInst.heapFloat[r2 + numDefine2];
        f11 = heapClassInst.heapFloat[r2 + numDefine8];
        f12 = heapClassInst.heapFloat[r2 + numDefine9];
        f13 = heapClassInst.heapFloat[r2 + numDefine10];
        f14 = heapClassInst.heapFloat[r2 + numDefine6];
        f7 = f7 * f2;
        f8 = f8 * f5;
        f4 = f4 - f6;
        f6 = f10 * f9;
        f2 = f11 * f2;
        f5 = f12 * f5;
        f7 = f7 - f8;
        f8 = f14 * f9;
        f4 = f4 - f6;
        f2 = f2 - f5;
        f5 = f13 * f9;
        f6 = f7 - f8;
        heapClassInst.heapFloat[r0 + numDefine8] = f4;
        f2 = f2 - f5;
        heapClassInst.heapFloat[r0 + numDefine9] = f6;
        r1 = heapClassInst.heap32[fp + numDefine4];
        heapClassInst.heapFloat[r0 + numDefine10] = f2;
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r0 + numDefine11] = 0;
        f5 = heapClassInst.heapFloat[r1 + numDefine2];
        f7 = heapClassInst.heapFloat[r1 + 1];
        f8 = heapClassInst.heapFloat[r1];
        f8 = f8 * f1;
        f7 = f7 * f3;
        heapClassInst.heapFloat[r0 + numDefine12] = f8;
        f5 = f5 * f0;
        heapClassInst.heapFloat[r0 + numDefine13] = f7;
        r1 = heapClassInst.heap32[fp + numDefine5];
        heapClassInst.heapFloat[r0 + numDefine14] = f5;
        r1 = r1 >> numDefine2;
        heapClassInst.heap32[r0 + numDefine15] = 0;
        f9 = heapClassInst.heapFloat[r1 + numDefine2];
        f10 = heapClassInst.heapFloat[r1 + 1];
        f11 = heapClassInst.heapFloat[r1];
        f10 = f10 * f6;
        f11 = f11 * f4;
        f9 = f9 * f2;
        heapClassInst.heapFloat[r0 + numDefine16] = f11;
        f1 = f8 * f1;
        f3 = f7 * f3;
        f4 = f11 * f4;
        f6 = f10 * f6;
        heapClassInst.heapFloat[r0 + numDefine17] = f10;
        f1 = f1 + f3;
        f0 = f5 * f0;
        f3 = f4 + f6;
        f2 = f9 * f2;
        heapClassInst.heapFloat[r0 + numDefine18] = f9;
        f0 = f1 + f0;
        f1 = f3 + f2;
        f0 = f0 + f1;
        heapClassInst.heap32[r0 + numDefine19] = 0;
        f1 = 0;
        heapClassInst.heapFloat[r0 + numDefine20] = f0;
        if (f0 > f1) {
            return;
        } else {
            r0 = twoEStr846;
            r1 = twoEStr947;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r1;
            heapClassInst.heap32[g0 + numDefine2] = numDefine70;
            assertNew(i7);
        }
    }

    public static void z21btAdjustAngleToLimitsfff(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        f0 = heapClassInst.heapFloat[fp + 1];
        f1 = heapClassInst.heapFloat[fp + numDefine2];
        f2 = heapClassInst.heapFloat[fp];
        repeat1: do {
            if (!(f0 >= f1)) {
                if (f2 >= f0) {
                    if (f2 <= f1) {
                        break repeat1;
                    } else {
                        f1 = f2 - f1;
                        heapClassInst.heapFloat[g0] = f1;
                        heapClassInst.heap32[g0 + 1] = numDefine18619;
                        fmodf(i7);
                        f1 = (float) commonVariable.fg0;
                        f3 = (float) numDefineNegFloat132;
                        if (f1 >= f3) {
                            f4 = (float) numDefineFloat132;
                            if (f1 > f4) {
                                f4 = (float) numDefineNegFloat265;
                                f1 = f1 + f4;
                            }
                        } else {
                            f4 = (float) numDefineFloat265;
                            f1 = f1 + f4;
                        }
                        f4 = 0;
                        if (f1 < f4) {
                            f1 = -f1;
                        }
                        f0 = f2 - f0;
                        heapClassInst.heapFloat[g0] = f0;
                        heapClassInst.heap32[g0 + 1] = numDefine18619;
                        fmodf(i7);
                        f0 = (float) commonVariable.fg0;
                        if (f0 >= f3) {
                            f3 = (float) numDefineFloat132;
                            if (f0 > f3) {
                                f3 = (float) numDefineNegFloat265;
                                f0 = f0 + f3;
                            }
                        } else {
                            f3 = (float) numDefineFloat265;
                            f0 = f0 + f3;
                        }
                        if (f0 < f4) {
                            f0 = -f0;
                        }
                        if (f0 >= f1) {
                            break repeat1;
                        } else {
                            f0 = (float) numDefineNegFloat265;
                            f2 = f2 + f0;
                        }
                    }
                } else {
                    f0 = f0 - f2;
                    heapClassInst.heapFloat[g0] = f0;
                    heapClassInst.heap32[g0 + 1] = numDefine18619;
                    fmodf(i7);
                    f0 = (float) commonVariable.fg0;
                    f3 = (float) numDefineNegFloat132;
                    if (f0 >= f3) {
                        f4 = (float) numDefineFloat132;
                        if (f0 > f4) {
                            f4 = (float) numDefineNegFloat265;
                            f0 = f0 + f4;
                        }
                    } else {
                        f4 = (float) numDefineFloat265;
                        f0 = f0 + f4;
                    }
                    f4 = 0;
                    if (f0 < f4) {
                        f0 = -f0;
                    }
                    f1 = f1 - f2;
                    heapClassInst.heapFloat[g0] = f1;
                    heapClassInst.heap32[g0 + 1] = numDefine18619;
                    fmodf(i7);
                    f1 = (float) commonVariable.fg0;
                    if (f1 >= f3) {
                        f3 = (float) numDefineFloat132;
                        if (f1 > f3) {
                            f3 = (float) numDefineNegFloat265;
                            f1 = f1 + f3;
                        }
                    } else {
                        f3 = (float) numDefineFloat265;
                        f1 = f1 + f3;
                    }
                    if (f1 < f4) {
                        f1 = -f1;
                    }
                    if (!(f0 < f1)) {
                        f0 = (float) numDefineFloat265;
                        f0 = f2 + f0;
                        commonVariable.fg0 = f0;
                        return;
                    }
                }
            }
        } while (false);
        commonVariable.fg0 = f2;
        return;
    }

    public static void znk17btHingeConstraint28calculateSerializeBufferSizeEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = numDefine212;
        commonVariable.rg0 = r0;
        return;
    }

    public static void znk17btHingeConstraint9serializeEPvP12btSerializer(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heap32[fp + numDefine2];
        heapClassInst.heap32[g0] = r0;
        heapClassInst.heap32[g0 + 1] = r1;
        heapClassInst.heap32[g0 + numDefine2] = r2;
        r1 = r1 >> numDefine2;
        r2 = r0 >> numDefine2;
        znk17btTypedConstraint9serializeEPvP12btSerializer(i7);
        heapClassInst.heap32[r1 + numDefine11] = heapClassInst.heap32[r2 + numDefine135];
        heapClassInst.heap32[r1 + numDefine12] = heapClassInst.heap32[r2 + numDefine136];
        heapClassInst.heap32[r1 + numDefine13] = heapClassInst.heap32[r2 + numDefine137];
        heapClassInst.heap32[r1 + numDefine14] = heapClassInst.heap32[r2 + numDefine138];
        heapClassInst.heap32[r1 + numDefine15] = heapClassInst.heap32[r2 + numDefine139];
        heapClassInst.heap32[r1 + numDefine16] = heapClassInst.heap32[r2 + numDefine140];
        heapClassInst.heap32[r1 + numDefine17] = heapClassInst.heap32[r2 + numDefine141];
        heapClassInst.heap32[r1 + numDefine18] = heapClassInst.heap32[r2 + numDefine142];
        heapClassInst.heap32[r1 + numDefine19] = heapClassInst.heap32[r2 + numDefine143];
        heapClassInst.heap32[r1 + numDefine20] = heapClassInst.heap32[r2 + numDefine144];
        heapClassInst.heap32[r1 + numDefine21] = heapClassInst.heap32[r2 + numDefine145];
        heapClassInst.heap32[r1 + numDefine22] = heapClassInst.heap32[r2 + numDefine146];
        heapClassInst.heap32[r1 + numDefine23] = heapClassInst.heap32[r2 + numDefine147];
        heapClassInst.heap32[r1 + numDefine24] = heapClassInst.heap32[r2 + numDefine148];
        heapClassInst.heap32[r1 + numDefine25] = heapClassInst.heap32[r2 + numDefine149];
        heapClassInst.heap32[r1 + numDefine26] = heapClassInst.heap32[r2 + numDefine150];
        heapClassInst.heap32[r1 + numDefine27] = heapClassInst.heap32[r2 + numDefine151];
        heapClassInst.heap32[r1 + numDefine28] = heapClassInst.heap32[r2 + numDefine152];
        heapClassInst.heap32[r1 + numDefine29] = heapClassInst.heap32[r2 + numDefine153];
        heapClassInst.heap32[r1 + numDefine30] = heapClassInst.heap32[r2 + numDefine154];
        heapClassInst.heap32[r1 + numDefine31] = heapClassInst.heap32[r2 + numDefine155];
        heapClassInst.heap32[r1 + numDefine32] = heapClassInst.heap32[r2 + numDefine156];
        heapClassInst.heap32[r1 + numDefine33] = heapClassInst.heap32[r2 + numDefine157];
        heapClassInst.heap32[r1 + numDefine34] = heapClassInst.heap32[r2 + numDefine158];
        heapClassInst.heap32[r1 + numDefine35] = heapClassInst.heap32[r2 + numDefine159];
        heapClassInst.heap32[r1 + numDefine36] = heapClassInst.heap32[r2 + numDefine160];
        heapClassInst.heap32[r1 + numDefine37] = heapClassInst.heap32[r2 + numDefine161];
        heapClassInst.heap32[r1 + numDefine38] = heapClassInst.heap32[r2 + numDefine162];
        heapClassInst.heap32[r1 + numDefine39] = heapClassInst.heap32[r2 + numDefine163];
        heapClassInst.heap32[r1 + numDefine40] = heapClassInst.heap32[r2 + numDefine164];
        heapClassInst.heap32[r1 + numDefine41] = heapClassInst.heap32[r2 + numDefine165];
        heapClassInst.heap32[r1 + numDefine42] = heapClassInst.heap32[r2 + numDefine166];
        r3 = heapClassInst.heapU8[r0 + numDefine720];
        heapClassInst.heap32[r1 + numDefine44] = r3;
        r3 = heapClassInst.heapU8[r0 + numDefine721];
        heapClassInst.heap32[r1 + numDefine45] = r3;
        heapClassInst.heap32[r1 + numDefine47] = heapClassInst.heap32[r2 + numDefine168];
        heapClassInst.heap32[r1 + numDefine46] = heapClassInst.heap32[r2 + numDefine167];
        r0 = heapClassInst.heapU8[r0 + numDefine725];
        heapClassInst.heap32[r1 + numDefine43] = r0;
        heapClassInst.heap32[r1 + numDefine48] = heapClassInst.heap32[r2 + numDefine172];
        heapClassInst.heap32[r1 + numDefine49] = heapClassInst.heap32[r2 + numDefine173];
        heapClassInst.heap32[r1 + numDefine50] = heapClassInst.heap32[r2 + numDefine169];
        heapClassInst.heap32[r1 + numDefine51] = heapClassInst.heap32[r2 + numDefine170];
        heapClassInst.heap32[r1 + numDefine52] = heapClassInst.heap32[r2 + numDefine171];
        r0 = twoEStr29;
        commonVariable.rg0 = r0;
        return;
    }

    public static void zn17btHingeConstraintD0Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv17btHingeConstraint;
        r2 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r2] = r1;
        heapClassInst.heap32[g0] = r0;
        zdlPv(i7);
        return;
    }

    public static void zn17btHingeConstraintD1Ev(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = ztv17btHingeConstraint;
        r0 = r0 >> numDefine2;
        r1 = (r1 + numDefine8) | 0;
        heapClassInst.heap32[r0] = r1;
        return;
    }

    public static void zn17btHingeConstraint13buildJacobianEv(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg552;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heapU8[r0 + numDefine723];
        if (!(r1 == 0)) {
            r1 = r0 >> numDefine2;
            heapClassInst.heap32[r1 + numDefine7] = 0;
            heapClassInst.heap32[r1 + numDefine182] = 0;
            r2 = heapClassInst.heapU8[r0 + numDefine720];
            if (!(r2 != 0)) {
                r2 = heapClassInst.heap32[r1 + numDefine6];
                r3 = heapClassInst.heap32[r1 + numDefine5];
                r2 = r2 >> numDefine2;
                r3 = r3 >> numDefine2;
                f0 = heapClassInst.heapFloat[r2 + numDefine5];
                f1 = heapClassInst.heapFloat[r1 + numDefine163];
                f2 = heapClassInst.heapFloat[r2 + 1];
                f3 = heapClassInst.heapFloat[r2 + numDefine6];
                f4 = heapClassInst.heapFloat[r1 + numDefine164];
                f5 = heapClassInst.heapFloat[r2 + numDefine2];
                f6 = heapClassInst.heapFloat[r3 + numDefine5];
                f7 = heapClassInst.heapFloat[r1 + numDefine147];
                f8 = heapClassInst.heapFloat[r3 + 1];
                f9 = heapClassInst.heapFloat[r3 + numDefine6];
                f10 = heapClassInst.heapFloat[r1 + numDefine148];
                f11 = heapClassInst.heapFloat[r3 + numDefine2];
                f12 = heapClassInst.heapFloat[r2 + numDefine9];
                f13 = heapClassInst.heapFloat[r2 + numDefine10];
                f14 = heapClassInst.heapFloat[r3 + numDefine9];
                f15 = heapClassInst.heapFloat[r3 + numDefine10];
                f0 = f0 * f1;
                f3 = f3 * f4;
                f16 = heapClassInst.heapFloat[r2 + numDefine7];
                f17 = heapClassInst.heapFloat[r1 + numDefine165];
                f18 = heapClassInst.heapFloat[r2 + numDefine3];
                f6 = f6 * f7;
                f9 = f9 * f10;
                f19 = heapClassInst.heapFloat[r3 + numDefine7];
                f20 = heapClassInst.heapFloat[r1 + numDefine149];
                f21 = heapClassInst.heapFloat[r3 + numDefine3];
                f2 = f2 * f1;
                f5 = f5 * f4;
                f8 = f8 * f7;
                f11 = f11 * f10;
                f22 = heapClassInst.heapFloat[r2 + numDefine11];
                f23 = heapClassInst.heapFloat[r3 + numDefine11];
                f1 = f12 * f1;
                f4 = f13 * f4;
                f7 = f14 * f7;
                f10 = f15 * f10;
                f0 = f0 + f3;
                f3 = f16 * f17;
                f6 = f6 + f9;
                f9 = f19 * f20;
                f2 = f2 + f5;
                f5 = f18 * f17;
                f8 = f8 + f11;
                f11 = f21 * f20;
                f1 = f1 + f4;
                f4 = f22 * f17;
                f7 = f7 + f10;
                f10 = f23 * f20;
                f0 = f0 + f3;
                f3 = heapClassInst.heapFloat[r2 + numDefine14];
                f6 = f6 + f9;
                f9 = heapClassInst.heapFloat[r3 + numDefine14];
                f2 = f2 + f5;
                f5 = heapClassInst.heapFloat[r2 + numDefine13];
                f8 = f8 + f11;
                f11 = heapClassInst.heapFloat[r3 + numDefine13];
                f0 = f0 + f3;
                f3 = f6 + f9;
                f2 = f2 + f5;
                f5 = f8 + f11;
                f1 = f1 + f4;
                f4 = heapClassInst.heapFloat[r2 + numDefine15];
                f6 = f7 + f10;
                f7 = heapClassInst.heapFloat[r3 + numDefine15];
                f8 = f0 - f3;
                f9 = f2 - f5;
                f1 = f1 + f4;
                f4 = f6 + f7;
                f6 = f1 - f4;
                f7 = f9 * f9;
                f10 = f8 * f8;
                f7 = f7 + f10;
                f10 = f6 * f6;
                f7 = f7 + f10;
                f10 = (float) numDefineFloat1257;
                if (f7 > f10) {
                    heapClassInst.heapFloat[g0] = f7;
                    f10 = 1;
                    sqrtf(i7);
                    f11 = (float) (f10 / commonVariable.fg0);
                    r2 = sp + numDefineNeg512;
                    f7 = f9 * f11;
                    f8 = f8 * f11;
                    r3 = r2 >> numDefine2;
                    heapClassInst.heapFloat[fp + numDefineNeg128] = f7;
                    f6 = f6 * f11;
                    heapClassInst.heapFloat[r3 + 1] = f8;
                    r2 = (r2 + numDefine8) | 0;
                    heapClassInst.heapFloat[r3 + numDefine2] = f6;
                    heapClassInst.heap32[r3 + numDefine3] = 0;
                    f9 = 0;
                    if (f6 < f9) {
                        f9 = -f6;
                    } else {
                        f9 = f6;
                    }
                    f11 = (float) numDefineFloat742;
                    if (f9 > f11) {
                        f7 = f8 * f8;
                        f8 = f6 * f6;
                        f7 = f7 + f8;
                        heapClassInst.heapFloat[g0] = f7;
                        sqrtf(i7);
                        heapClassInst.heap32[r3 + numDefine4] = 0;
                        f6 = heapClassInst.heapFloat[r3 + numDefine2];
                        f8 = (float) (f10 / commonVariable.fg0);
                        f6 = -f6;
                        f6 = f8 * f6;
                        heapClassInst.heapFloat[r3 + numDefine5] = f6;
                        f9 = heapClassInst.heapFloat[r3 + 1];
                        f9 = f9 * f8;
                        f7 = f7 * f8;
                        heapClassInst.heapFloat[r3 + numDefine6] = f9;
                        heapClassInst.heapFloat[r3 + numDefine8] = f7;
                        f7 = heapClassInst.heapFloat[fp + numDefineNeg128];
                        f8 = -f7;
                        f8 = f9 * f8;
                        f7 = f7 * f6;
                        heapClassInst.heapFloat[r3 + numDefine9] = f8;
                        heapClassInst.heapFloat[r3 + numDefine10] = f7;
                        label = numDefine10;
                    } else {
                        label = numDefine9;
                    }
                } else {
                    r2 = sp + numDefineNeg512;
                    r3 = r2 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg128] = numDefine53216;
                    heapClassInst.heap32[r3 + 1] = 0;
                    r2 = (r2 + numDefine8) | 0;
                    f7 = 1;
                    f8 = 0;
                    heapClassInst.heap32[r3 + numDefine2] = 0;
                    heapClassInst.heap32[r3 + numDefine3] = 0;
                    label = numDefine9;
                }
                if (label == numDefine9) {
                    f6 = f7 * f7;
                    f7 = f8 * f8;
                    f6 = f6 + f7;
                    r3 = sp + numDefineNeg512;
                    heapClassInst.heapFloat[g0] = f6;
                    r3 = r3 >> numDefine2;
                    sqrtf(i7);
                    f8 = 1;
                    f9 = heapClassInst.heapFloat[r3 + 1];
                    f7 = (float) (f8 / commonVariable.fg0);
                    f8 = -f9;
                    f8 = f7 * f8;
                    heapClassInst.heapFloat[r3 + numDefine4] = f8;
                    f9 = heapClassInst.heapFloat[fp + numDefineNeg128];
                    f9 = f9 * f7;
                    heapClassInst.heapFloat[r3 + numDefine5] = f9;
                    r2 = r2 >> numDefine2;
                    heapClassInst.heap32[r3 + numDefine6] = 0;
                    f10 = heapClassInst.heapFloat[r2];
                    f11 = -f10;
                    f9 = f9 * f11;
                    f8 = f10 * f8;
                    heapClassInst.heapFloat[r3 + numDefine8] = f9;
                    f6 = f6 * f7;
                    heapClassInst.heapFloat[r3 + numDefine9] = f8;
                    heapClassInst.heapFloat[r3 + numDefine10] = f6;
                }
                r2 = (r0 + numDefine36) | 0;
                r3 = 0;
                repeat16: while (true) {
                    r4 = heapClassInst.heap32[r1 + numDefine5];
                    r5 = r4 >> numDefine2;
                    r6 = sp + numDefineNeg416;
                    r7 = r6 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg104] = heapClassInst.heap32[r5 + 1];
                    heapClassInst.heap32[r7 + 1] = heapClassInst.heap32[r5 + numDefine5];
                    heapClassInst.heap32[r7 + numDefine2] = heapClassInst.heap32[r5 + numDefine9];
                    heapClassInst.heap32[r7 + numDefine3] = 0;
                    heapClassInst.heap32[r7 + numDefine4] = heapClassInst.heap32[r5 + numDefine2];
                    heapClassInst.heap32[r7 + numDefine5] = heapClassInst.heap32[r5 + numDefine6];
                    heapClassInst.heap32[r7 + numDefine6] = heapClassInst.heap32[r5 + numDefine10];
                    heapClassInst.heap32[r7 + numDefine7] = 0;
                    heapClassInst.heap32[r7 + numDefine8] = heapClassInst.heap32[r5 + numDefine3];
                    heapClassInst.heap32[r7 + numDefine9] = heapClassInst.heap32[r5 + numDefine7];
                    heapClassInst.heap32[r7 + numDefine10] = heapClassInst.heap32[r5 + numDefine11];
                    heapClassInst.heap32[r7 + numDefine11] = 0;
                    r7 = heapClassInst.heap32[r1 + numDefine6];
                    r8 = sp + numDefineNeg368;
                    r9 = r7 >> numDefine2;
                    r10 = r8 >> numDefine2;
                    heapClassInst.heap32[fp + numDefineNeg92] = heapClassInst.heap32[r9 + 1];
                    heapClassInst.heap32[r10 + 1] = heapClassInst.heap32[r9 + numDefine5];
                    heapClassInst.heap32[r10 + numDefine2] = heapClassInst.heap32[r9 + numDefine9];
                    heapClassInst.heap32[r10 + numDefine3] = 0;
                    heapClassInst.heap32[r10 + numDefine4] = heapClassInst.heap32[r9 + numDefine2];
                    heapClassInst.heap32[r10 + numDefine5] = heapClassInst.heap32[r9 + numDefine6];
                    heapClassInst.heap32[r10 + numDefine6] = heapClassInst.heap32[r9 + numDefine10];
                    heapClassInst.heap32[r10 + numDefine7] = 0;
                    heapClassInst.heap32[r10 + numDefine8] = heapClassInst.heap32[r9 + numDefine3];
                    heapClassInst.heap32[r10 + numDefine9] = heapClassInst.heap32[r9 + numDefine7];
                    heapClassInst.heap32[r10 + numDefine10] = heapClassInst.heap32[r9 + numDefine11];
                    heapClassInst.heap32[r10 + numDefine11] = 0;
                    f6 = heapClassInst.heapFloat[r5 + numDefine13];
                    f7 = heapClassInst.heapFloat[r5 + numDefine15];
                    f8 = heapClassInst.heapFloat[r5 + numDefine14];
                    r10 = sp + numDefineNeg320;
                    f6 = f5 - f6;
                    r11 = r10 >> numDefine2;
                    f8 = f3 - f8;
                    heapClassInst.heapFloat[fp + numDefineNeg80] = f6;
                    f6 = f4 - f7;
                    heapClassInst.heapFloat[r11 + 1] = f8;
                    heapClassInst.heapFloat[r11 + numDefine2] = f6;
                    heapClassInst.heap32[r11 + numDefine3] = 0;
                    f6 = heapClassInst.heapFloat[r9 + numDefine13];
                    f7 = heapClassInst.heapFloat[r9 + numDefine15];
                    f8 = heapClassInst.heapFloat[r9 + numDefine14];
                    r11 = sp + numDefineNeg304;
                    f6 = f2 - f6;
                    r12 = r11 >> numDefine2;
                    f8 = f0 - f8;
                    heapClassInst.heapFloat[fp + numDefineNeg76] = f6;
                    f6 = f1 - f7;
                    heapClassInst.heapFloat[r12 + 1] = f8;
                    heapClassInst.heapFloat[r12 + numDefine2] = f6;
                    heapClassInst.heap32[r12 + numDefine3] = 0;
                    f6 = heapClassInst.heapFloat[r9 + numDefine84];
                    f7 = heapClassInst.heapFloat[r5 + numDefine84];
                    r5 = sp + numDefineNeg512;
                    r5 = (r5 + r3) | 0;
                    r4 = (r4 + numDefine388) | 0;
                    r7 = (r7 + numDefine388) | 0;
                    heapClassInst.heap32[g0] = r2;
                    heapClassInst.heap32[g0 + 1] = r6;
                    heapClassInst.heap32[g0 + numDefine2] = r8;
                    heapClassInst.heap32[g0 + numDefine3] = r10;
                    heapClassInst.heap32[g0 + numDefine4] = r11;
                    heapClassInst.heap32[g0 + numDefine5] = r5;
                    heapClassInst.heap32[g0 + numDefine6] = r4;
                    heapClassInst.heapFloat[g0 + numDefine7] = f7;
                    heapClassInst.heap32[g0 + numDefine8] = r7;
                    heapClassInst.heapFloat[g0 + numDefine9] = f6;
                    r3 = (r3 + numDefine16) | 0;
                    r2 = (r2 + numDefine84) | 0;
                    zn15btJacobianEntryC2ERK11btMatrix3x3S2RK9btVector3S5S5S5FS5F(i7);
                    if (!(r3 != numDefine48)) {
                        break repeat16;
                    }
                }
            }
            f0 = heapClassInst.heapFloat[r1 + numDefine145];
            f1 = heapClassInst.heapFloat[r1 + numDefine137];
            f2 = heapClassInst.heapFloat[r1 + numDefine141];
            f3 = 0;
            if (f0 < f3) {
                f4 = -f0;
            } else {
                f4 = f0;
            }
            f5 = (float) numDefineFloat742;
            if (f4 <= f5) {
                f4 = f1 * f1;
                f6 = f2 * f2;
                f5 = f4 + f6;
                heapClassInst.heapFloat[g0] = f5;
                f4 = 1;
                sqrtf(i7);
                f7 = (float) (f4 / commonVariable.fg0);
                f2 = -f2;
                f4 = f7 * f2;
                f6 = f1 * f7;
                f1 = -f0;
                f2 = f6 * f1;
                f0 = f0 * f4;
                f1 = f5 * f7;
            } else {
                f3 = f2 * f2;
                f4 = f0 * f0;
                f4 = f3 + f4;
                heapClassInst.heapFloat[g0] = f4;
                f3 = 1;
                sqrtf(i7);
                f5 = (float) (f3 / commonVariable.fg0);
                f0 = -f0;
                f6 = f5 * f0;
                f3 = f2 * f5;
                f0 = -f1;
                f2 = f4 * f5;
                f0 = f3 * f0;
                f1 = f1 * f6;
                f4 = 0;
            }
            r2 = heapClassInst.heap32[r1 + numDefine5];
            r3 = r2 >> numDefine2;
            f5 = heapClassInst.heapFloat[r3 + numDefine2];
            f7 = heapClassInst.heapFloat[r3 + 1];
            f8 = heapClassInst.heapFloat[r3 + numDefine6];
            f9 = heapClassInst.heapFloat[r3 + numDefine5];
            f10 = heapClassInst.heapFloat[r3 + numDefine3];
            f11 = f7 * f4;
            f12 = f5 * f6;
            f13 = heapClassInst.heapFloat[r3 + numDefine11];
            f14 = heapClassInst.heapFloat[r3 + numDefine7];
            f15 = heapClassInst.heapFloat[r3 + numDefine10];
            f16 = heapClassInst.heapFloat[r3 + numDefine9];
            f17 = f9 * f4;
            f18 = f8 * f6;
            f11 = f11 + f12;
            f12 = f10 * f3;
            r3 = sp + numDefineNeg432;
            f4 = f16 * f4;
            f6 = f15 * f6;
            f17 = f17 + f18;
            f18 = f14 * f3;
            f11 = f11 + f12;
            r4 = r3 >> numDefine2;
            f4 = f4 + f6;
            f3 = f13 * f3;
            f6 = f17 + f18;
            heapClassInst.heapFloat[fp + numDefineNeg108] = f11;
            f11 = f7 * f2;
            f12 = f5 * f0;
            f3 = f4 + f3;
            heapClassInst.heapFloat[r4 + 1] = f6;
            heapClassInst.heapFloat[r4 + numDefine2] = f3;
            f3 = f9 * f2;
            f4 = f8 * f0;
            f6 = f11 + f12;
            f11 = f10 * f1;
            r5 = sp + numDefineNeg448;
            f2 = f16 * f2;
            f0 = f15 * f0;
            f3 = f3 + f4;
            f4 = f14 * f1;
            f6 = f6 + f11;
            heapClassInst.heap32[r4 + numDefine3] = 0;
            r4 = r5 >> numDefine2;
            f0 = f2 + f0;
            f1 = f13 * f1;
            f2 = f3 + f4;
            heapClassInst.heapFloat[fp + numDefineNeg112] = f6;
            f0 = f0 + f1;
            heapClassInst.heapFloat[r4 + 1] = f2;
            heapClassInst.heapFloat[r4 + numDefine2] = f0;
            heapClassInst.heap32[r4 + numDefine3] = 0;
            f0 = heapClassInst.heapFloat[r1 + numDefine137];
            f1 = heapClassInst.heapFloat[r1 + numDefine141];
            f2 = heapClassInst.heapFloat[r1 + numDefine145];
            f3 = f7 * f0;
            f4 = f5 * f1;
            f6 = f9 * f0;
            f11 = f8 * f1;
            f3 = f3 + f4;
            f4 = f10 * f2;
            r4 = sp + numDefineNeg464;
            f0 = f16 * f0;
            f1 = f15 * f1;
            f6 = f6 + f11;
            f11 = f14 * f2;
            f3 = f3 + f4;
            r6 = r4 >> numDefine2;
            f0 = f0 + f1;
            f1 = f13 * f2;
            f2 = f6 + f11;
            heapClassInst.heapFloat[fp + numDefineNeg116] = f3;
            f0 = f0 + f1;
            heapClassInst.heapFloat[r6 + 1] = f2;
            heapClassInst.heapFloat[r6 + numDefine2] = f0;
            r7 = sp + numDefineNeg288;
            heapClassInst.heap32[r6 + numDefine3] = 0;
            r6 = r7 >> numDefine2;
            heapClassInst.heapFloat[fp + numDefineNeg72] = f7;
            heapClassInst.heapFloat[r6 + 1] = f9;
            heapClassInst.heapFloat[r6 + numDefine2] = f16;
            heapClassInst.heap32[r6 + numDefine3] = 0;
            heapClassInst.heapFloat[r6 + numDefine4] = f5;
            heapClassInst.heapFloat[r6 + numDefine5] = f8;
            heapClassInst.heapFloat[r6 + numDefine6] = f15;
            heapClassInst.heap32[r6 + numDefine7] = 0;
            heapClassInst.heapFloat[r6 + numDefine8] = f10;
            heapClassInst.heapFloat[r6 + numDefine9] = f14;
            heapClassInst.heapFloat[r6 + numDefine10] = f13;
            heapClassInst.heap32[r6 + numDefine11] = 0;
            r6 = heapClassInst.heap32[r1 + numDefine6];
            r8 = sp + numDefineNeg240;
            r9 = r6 >> numDefine2;
            r10 = r8 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg60] = heapClassInst.heap32[r9 + 1];
            heapClassInst.heap32[r10 + 1] = heapClassInst.heap32[r9 + numDefine5];
            heapClassInst.heap32[r10 + numDefine2] = heapClassInst.heap32[r9 + numDefine9];
            heapClassInst.heap32[r10 + numDefine3] = 0;
            heapClassInst.heap32[r10 + numDefine4] = heapClassInst.heap32[r9 + numDefine2];
            heapClassInst.heap32[r10 + numDefine5] = heapClassInst.heap32[r9 + numDefine6];
            heapClassInst.heap32[r10 + numDefine6] = heapClassInst.heap32[r9 + numDefine10];
            heapClassInst.heap32[r10 + numDefine7] = 0;
            heapClassInst.heap32[r10 + numDefine8] = heapClassInst.heap32[r9 + numDefine3];
            heapClassInst.heap32[r10 + numDefine9] = heapClassInst.heap32[r9 + numDefine7];
            heapClassInst.heap32[r10 + numDefine10] = heapClassInst.heap32[r9 + numDefine11];
            heapClassInst.heap32[r10 + numDefine11] = 0;
            r9 = (r0 + numDefine288) | 0;
            r2 = (r2 + numDefine388) | 0;
            r6 = (r6 + numDefine388) | 0;
            heapClassInst.heap32[g0] = r9;
            heapClassInst.heap32[g0 + 1] = r3;
            heapClassInst.heap32[g0 + numDefine2] = r7;
            heapClassInst.heap32[g0 + numDefine3] = r8;
            heapClassInst.heap32[g0 + numDefine4] = r2;
            heapClassInst.heap32[g0 + numDefine5] = r6;
            zn15btJacobianEntryC2ERK9btVector3RK11btMatrix3x3S5S2S2(i7);
            r2 = heapClassInst.heap32[r1 + numDefine5];
            r3 = sp + numDefineNeg192;
            r6 = r2 >> numDefine2;
            r7 = r3 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg48] = heapClassInst.heap32[r6 + 1];
            heapClassInst.heap32[r7 + 1] = heapClassInst.heap32[r6 + numDefine5];
            heapClassInst.heap32[r7 + numDefine2] = heapClassInst.heap32[r6 + numDefine9];
            heapClassInst.heap32[r7 + numDefine3] = 0;
            heapClassInst.heap32[r7 + numDefine4] = heapClassInst.heap32[r6 + numDefine2];
            heapClassInst.heap32[r7 + numDefine5] = heapClassInst.heap32[r6 + numDefine6];
            heapClassInst.heap32[r7 + numDefine6] = heapClassInst.heap32[r6 + numDefine10];
            heapClassInst.heap32[r7 + numDefine7] = 0;
            heapClassInst.heap32[r7 + numDefine8] = heapClassInst.heap32[r6 + numDefine3];
            heapClassInst.heap32[r7 + numDefine9] = heapClassInst.heap32[r6 + numDefine7];
            heapClassInst.heap32[r7 + numDefine10] = heapClassInst.heap32[r6 + numDefine11];
            heapClassInst.heap32[r7 + numDefine11] = 0;
            r6 = heapClassInst.heap32[r1 + numDefine6];
            r7 = sp + numDefineNeg144;
            r8 = r6 >> numDefine2;
            r9 = r7 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg36] = heapClassInst.heap32[r8 + 1];
            heapClassInst.heap32[r9 + 1] = heapClassInst.heap32[r8 + numDefine5];
            heapClassInst.heap32[r9 + numDefine2] = heapClassInst.heap32[r8 + numDefine9];
            heapClassInst.heap32[r9 + numDefine3] = 0;
            heapClassInst.heap32[r9 + numDefine4] = heapClassInst.heap32[r8 + numDefine2];
            heapClassInst.heap32[r9 + numDefine5] = heapClassInst.heap32[r8 + numDefine6];
            heapClassInst.heap32[r9 + numDefine6] = heapClassInst.heap32[r8 + numDefine10];
            heapClassInst.heap32[r9 + numDefine7] = 0;
            heapClassInst.heap32[r9 + numDefine8] = heapClassInst.heap32[r8 + numDefine3];
            heapClassInst.heap32[r9 + numDefine9] = heapClassInst.heap32[r8 + numDefine7];
            heapClassInst.heap32[r9 + numDefine10] = heapClassInst.heap32[r8 + numDefine11];
            heapClassInst.heap32[r9 + numDefine11] = 0;
            r8 = (r0 + numDefine372) | 0;
            r2 = (r2 + numDefine388) | 0;
            r6 = (r6 + numDefine388) | 0;
            heapClassInst.heap32[g0] = r8;
            heapClassInst.heap32[g0 + 1] = r5;
            heapClassInst.heap32[g0 + numDefine2] = r3;
            heapClassInst.heap32[g0 + numDefine3] = r7;
            heapClassInst.heap32[g0 + numDefine4] = r2;
            heapClassInst.heap32[g0 + numDefine5] = r6;
            zn15btJacobianEntryC2ERK9btVector3RK11btMatrix3x3S5S2S2(i7);
            r2 = heapClassInst.heap32[r1 + numDefine5];
            r3 = sp + numDefineNeg96;
            r5 = r2 >> numDefine2;
            r6 = r3 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg24] = heapClassInst.heap32[r5 + 1];
            heapClassInst.heap32[r6 + 1] = heapClassInst.heap32[r5 + numDefine5];
            heapClassInst.heap32[r6 + numDefine2] = heapClassInst.heap32[r5 + numDefine9];
            heapClassInst.heap32[r6 + numDefine3] = 0;
            heapClassInst.heap32[r6 + numDefine4] = heapClassInst.heap32[r5 + numDefine2];
            heapClassInst.heap32[r6 + numDefine5] = heapClassInst.heap32[r5 + numDefine6];
            heapClassInst.heap32[r6 + numDefine6] = heapClassInst.heap32[r5 + numDefine10];
            heapClassInst.heap32[r6 + numDefine7] = 0;
            heapClassInst.heap32[r6 + numDefine8] = heapClassInst.heap32[r5 + numDefine3];
            heapClassInst.heap32[r6 + numDefine9] = heapClassInst.heap32[r5 + numDefine7];
            heapClassInst.heap32[r6 + numDefine10] = heapClassInst.heap32[r5 + numDefine11];
            heapClassInst.heap32[r6 + numDefine11] = 0;
            r5 = heapClassInst.heap32[r1 + numDefine6];
            r6 = sp + numDefineNeg48;
            r7 = r5 >> numDefine2;
            r8 = r6 >> numDefine2;
            heapClassInst.heap32[fp + numDefineNeg12] = heapClassInst.heap32[r7 + 1];
            heapClassInst.heap32[r8 + 1] = heapClassInst.heap32[r7 + numDefine5];
            heapClassInst.heap32[r8 + numDefine2] = heapClassInst.heap32[r7 + numDefine9];
            heapClassInst.heap32[r8 + numDefine3] = 0;
            heapClassInst.heap32[r8 + numDefine4] = heapClassInst.heap32[r7 + numDefine2];
            heapClassInst.heap32[r8 + numDefine5] = heapClassInst.heap32[r7 + numDefine6];
            heapClassInst.heap32[r8 + numDefine6] = heapClassInst.heap32[r7 + numDefine10];
            heapClassInst.heap32[r8 + numDefine7] = 0;
            heapClassInst.heap32[r8 + numDefine8] = heapClassInst.heap32[r7 + numDefine3];
            heapClassInst.heap32[r8 + numDefine9] = heapClassInst.heap32[r7 + numDefine7];
            heapClassInst.heap32[r8 + numDefine10] = heapClassInst.heap32[r7 + numDefine11];
            heapClassInst.heap32[r8 + numDefine11] = 0;
            r7 = (r0 + numDefine456) | 0;
            r2 = (r2 + numDefine388) | 0;
            r5 = (r5 + numDefine388) | 0;
            heapClassInst.heap32[g0] = r7;
            heapClassInst.heap32[g0 + 1] = r4;
            heapClassInst.heap32[g0 + numDefine2] = r3;
            heapClassInst.heap32[g0 + numDefine3] = r6;
            heapClassInst.heap32[g0 + numDefine4] = r2;
            heapClassInst.heap32[g0 + numDefine5] = r5;
            zn15btJacobianEntryC2ERK9btVector3RK11btMatrix3x3S5S2S2(i7);
            heapClassInst.heap32[r1 + numDefine177] = 0;
            r2 = heapClassInst.heap32[r1 + numDefine6];
            r3 = heapClassInst.heap32[r1 + numDefine5];
            r3 = (r3 + numDefine4) | 0;
            r2 = (r2 + numDefine4) | 0;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r3;
            heapClassInst.heap32[g0 + numDefine2] = r2;
            zn17btHingeConstraint13getHingeAngleERK11btTransformS2(i7);
            f0 = (float) commonVariable.fg0;
            heapClassInst.heapFloat[r1 + numDefine178] = f0;
            heapClassInst.heap32[r1 + numDefine176] = 0;
            r2 = 0;
            heapClassInst.heap32[r1 + numDefine175] = 0;
            heapClassInst.heap8[r0 + numDefine722] = (byte) r2;
            f1 = heapClassInst.heapFloat[r1 + numDefine172];
            f2 = heapClassInst.heapFloat[r1 + numDefine173];
            if (!(f1 > f2)) {
                heapClassInst.heapFloat[g0] = f0;
                heapClassInst.heapFloat[g0 + 1] = f1;
                heapClassInst.heapFloat[g0 + numDefine2] = f2;
                z21btAdjustAngleToLimitsfff(i7);
                f0 = (float) commonVariable.fg0;
                heapClassInst.heapFloat[r1 + numDefine178] = f0;
                f1 = heapClassInst.heapFloat[r1 + numDefine172];
                if (f0 > f1) {
                    f1 = heapClassInst.heapFloat[r1 + numDefine173];
                    if (!(f0 < f1)) {
                        f0 = f1 - f0;
                        heapClassInst.heapFloat[r1 + numDefine176] = f0;
                        r2 = 1;
                        heapClassInst.heap32[r1 + numDefine175] = numDefineNeg30432;
                        heapClassInst.heap8[r0 + numDefine722] = (byte) r2;
                    }
                } else {
                    f0 = f1 - f0;
                    heapClassInst.heapFloat[r1 + numDefine176] = f0;
                    r2 = 1;
                    heapClassInst.heap32[r1 + numDefine175] = numDefine53216;
                    heapClassInst.heap8[r0 + numDefine722] = (byte) r2;
                }
            }
            r0 = heapClassInst.heap32[r1 + numDefine5];
            r0 = r0 >> numDefine2;
            f0 = heapClassInst.heapFloat[r1 + numDefine137];
            f1 = heapClassInst.heapFloat[r0 + numDefine5];
            f2 = heapClassInst.heapFloat[r0 + 1];
            f3 = heapClassInst.heapFloat[r1 + numDefine141];
            f4 = heapClassInst.heapFloat[r0 + numDefine6];
            f5 = heapClassInst.heapFloat[r0 + numDefine2];
            f6 = heapClassInst.heapFloat[r0 + numDefine9];
            f7 = heapClassInst.heapFloat[r0 + numDefine10];
            r2 = heapClassInst.heap32[r1 + numDefine6];
            f2 = f2 * f0;
            f5 = f5 * f3;
            f1 = f1 * f0;
            f4 = f4 * f3;
            f8 = heapClassInst.heapFloat[r1 + numDefine145];
            f9 = heapClassInst.heapFloat[r0 + numDefine7];
            f10 = heapClassInst.heapFloat[r0 + numDefine3];
            r2 = r2 >> numDefine2;
            f11 = heapClassInst.heapFloat[r0 + numDefine11];
            f0 = f6 * f0;
            f3 = f7 * f3;
            f2 = f2 + f5;
            f5 = f10 * f8;
            f1 = f1 + f4;
            f4 = f9 * f8;
            f0 = f0 + f3;
            f3 = f11 * f8;
            f2 = f2 + f5;
            f5 = heapClassInst.heapFloat[r0 + numDefine65];
            f6 = heapClassInst.heapFloat[r0 + numDefine64];
            f7 = heapClassInst.heapFloat[r2 + numDefine65];
            f8 = heapClassInst.heapFloat[r2 + numDefine64];
            f1 = f1 + f4;
            f4 = heapClassInst.heapFloat[r0 + numDefine69];
            f9 = heapClassInst.heapFloat[r0 + numDefine68];
            f10 = heapClassInst.heapFloat[r2 + numDefine69];
            f11 = heapClassInst.heapFloat[r2 + numDefine68];
            f12 = heapClassInst.heapFloat[r0 + numDefine66];
            f13 = heapClassInst.heapFloat[r0 + numDefine70];
            f14 = heapClassInst.heapFloat[r2 + numDefine66];
            f15 = heapClassInst.heapFloat[r2 + numDefine70];
            f6 = f6 * f2;
            f9 = f9 * f1;
            f5 = f5 * f2;
            f4 = f4 * f1;
            f8 = f8 * f2;
            f11 = f11 * f1;
            f7 = f7 * f2;
            f10 = f10 * f1;
            f0 = f0 + f3;
            f3 = heapClassInst.heapFloat[r0 + numDefine73];
            f16 = heapClassInst.heapFloat[r0 + numDefine72];
            f17 = heapClassInst.heapFloat[r2 + numDefine73];
            f18 = heapClassInst.heapFloat[r2 + numDefine72];
            f19 = heapClassInst.heapFloat[r0 + numDefine74];
            f20 = heapClassInst.heapFloat[r2 + numDefine74];
            f6 = f6 + f9;
            f9 = f16 * f0;
            f4 = f5 + f4;
            f3 = f3 * f0;
            f5 = f12 * f2;
            f12 = f13 * f1;
            f8 = f8 + f11;
            f11 = f18 * f0;
            f7 = f7 + f10;
            f10 = f17 * f0;
            f13 = f14 * f2;
            f14 = f15 * f1;
            f6 = f6 + f9;
            f3 = f4 + f3;
            f4 = f8 + f11;
            f7 = f7 + f10;
            f5 = f5 + f12;
            f8 = f19 * f0;
            f9 = f13 + f14;
            f10 = f20 * f0;
            f5 = f5 + f8;
            f8 = f9 + f10;
            f6 = f2 * f6;
            f3 = f1 * f3;
            f2 = f2 * f4;
            f1 = f1 * f7;
            f3 = f6 + f3;
            f4 = f0 * f5;
            f1 = f2 + f1;
            f0 = f0 * f8;
            f2 = f3 + f4;
            f0 = f1 + f0;
            f1 = 1;
            f0 = f2 + f0;
            f0 = f1 / f0;
            heapClassInst.heapFloat[r1 + numDefine174] = f0;
        }
        return;
    }

    public static void zn17btHingeConstraint8getInfo1EPN17btTypedConstraint17btConstraintInfo1E(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        r2 = heapClassInst.heapU8[r0 + numDefine723];
        if (r2 == 0) {
            r1 = r1 >> numDefine2;
            heapClassInst.heap32[r1] = numDefine5;
            heapClassInst.heap32[r1 + 1] = 1;
            r2 = r0 >> numDefine2;
            r3 = heapClassInst.heap32[r2 + numDefine6];
            r4 = heapClassInst.heap32[r2 + numDefine5];
            r4 = (r4 + numDefine4) | 0;
            r3 = (r3 + numDefine4) | 0;
            heapClassInst.heap32[g0] = r0;
            heapClassInst.heap32[g0 + 1] = r4;
            heapClassInst.heap32[g0 + numDefine2] = r3;
            zn17btHingeConstraint13getHingeAngleERK11btTransformS2(i7);
            f0 = (float) commonVariable.fg0;
            heapClassInst.heapFloat[r2 + numDefine178] = f0;
            heapClassInst.heap32[r2 + numDefine176] = 0;
            r3 = 0;
            heapClassInst.heap32[r2 + numDefine175] = 0;
            heapClassInst.heap8[r0 + numDefine722] = (byte) r3;
            f1 = heapClassInst.heapFloat[r2 + numDefine172];
            f2 = heapClassInst.heapFloat[r2 + numDefine173];
            if (f1 > f2) {
                label = numDefine8;
            } else {
                heapClassInst.heapFloat[g0] = f0;
                heapClassInst.heapFloat[g0 + 1] = f1;
                heapClassInst.heapFloat[g0 + numDefine2] = f2;
                z21btAdjustAngleToLimitsfff(i7);
                f0 = (float) commonVariable.fg0;
                heapClassInst.heapFloat[r2 + numDefine178] = f0;
                f1 = heapClassInst.heapFloat[r2 + numDefine172];
                if (f0 > f1) {
                    f1 = heapClassInst.heapFloat[r2 + numDefine173];
                    if (f0 < f1) {
                        r2 = heapClassInst.heapU8[r0 + numDefine722];
                        if (r2 != 0) {
                            label = numDefine10;
                        } else {
                            label = numDefine8;
                        }
                    } else {
                        f0 = f1 - f0;
                        heapClassInst.heapFloat[r2 + numDefine176] = f0;
                        r3 = 1;
                        heapClassInst.heap32[r2 + numDefine175] = numDefineNeg30432;
                        heapClassInst.heap8[r0 + numDefine722] = (byte) r3;
                        label = numDefine10;
                    }
                } else {
                    f0 = f1 - f0;
                    heapClassInst.heapFloat[r2 + numDefine176] = f0;
                    r3 = 1;
                    heapClassInst.heap32[r2 + numDefine175] = numDefine53216;
                    heapClassInst.heap8[r0 + numDefine722] = (byte) r3;
                    label = numDefine10;
                }
            }
            if (label == numDefine8) {
                r0 = heapClassInst.heapU8[r0 + numDefine721];
                if (!(r0 != 0)) {
                    return;
                }
            }
            r0 = heapClassInst.heap32[r1];
            r0 = (r0 + 1) | 0;
            heapClassInst.heap32[r1] = r0;
            r0 = heapClassInst.heap32[r1 + 1];
            r0 = (r0 + -1) | 0;
            heapClassInst.heap32[r1 + 1] = r0;
            return;
        } else {
            r0 = r1 >> numDefine2;
            heapClassInst.heap32[r0] = 0;
            heapClassInst.heap32[r0 + 1] = 0;
            return;
        }
    }

    public static void zn17btHingeConstraint8getInfo2EPN17btTypedConstraint17btConstraintInfo2E(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        int r3 = 0;
        int r4 = 0;
        int r5 = 0;
        int r6 = 0;
        int r7 = 0;
        int r8 = 0;
        int r9 = 0;
        int r10 = 0;
        int r11 = 0;
        int r12 = 0;
        int r13 = 0;
        int r14 = 0;
        int r15 = 0;
        int r16 = 0;
        int r17 = 0;
        int r18 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        float f30 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg136;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[fp + 1];
        r3 = heapClassInst.heap32[r1 + numDefine6];
        r4 = heapClassInst.heap32[r1 + numDefine5];
        r5 = heapClassInst.heapU8[r0 + numDefine723];
        r6 = heapClassInst.heapU8[r0 + numDefine724];
        repeat1: do {
            if (r6 == 0) {
                r5 = r5 & numDefine255;
                if (r5 == 0) {
                    r4 = r4 >> numDefine2;
                    r3 = r3 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r1 + numDefine147];
                    f1 = heapClassInst.heapFloat[r4 + numDefine9];
                    f2 = heapClassInst.heapFloat[r4 + numDefine5];
                    f3 = heapClassInst.heapFloat[r4 + 1];
                    f4 = heapClassInst.heapFloat[r1 + numDefine148];
                    f5 = heapClassInst.heapFloat[r4 + numDefine10];
                    f6 = heapClassInst.heapFloat[r4 + numDefine6];
                    f7 = heapClassInst.heapFloat[r4 + numDefine2];
                    f8 = heapClassInst.heapFloat[r1 + numDefine163];
                    f9 = heapClassInst.heapFloat[r3 + numDefine9];
                    heapClassInst.heapFloat[fp + numDefineNeg3] = f9;
                    f10 = heapClassInst.heapFloat[r3 + numDefine5];
                    heapClassInst.heapFloat[fp + numDefineNeg2] = f10;
                    f11 = heapClassInst.heapFloat[r3 + 1];
                    heapClassInst.heapFloat[fp + -1] = f11;
                    f12 = heapClassInst.heapFloat[r1 + numDefine164];
                    f13 = heapClassInst.heapFloat[r3 + numDefine10];
                    f14 = heapClassInst.heapFloat[r3 + numDefine6];
                    f9 = heapClassInst.heapFloat[r3 + numDefine2];
                    heapClassInst.heapFloat[fp + numDefineNeg7] = f9;
                    f10 = heapClassInst.heapFloat[r1 + numDefine137];
                    f11 = heapClassInst.heapFloat[r1 + numDefine141];
                    f15 = heapClassInst.heapFloat[r1 + numDefine136];
                    f16 = heapClassInst.heapFloat[r1 + numDefine140];
                    f17 = heapClassInst.heapFloat[r1 + numDefine135];
                    f18 = heapClassInst.heapFloat[r1 + numDefine139];
                    f19 = heapClassInst.heapFloat[r1 + numDefine153];
                    f20 = heapClassInst.heapFloat[r1 + numDefine157];
                    f21 = f1 * f0;
                    f22 = f5 * f4;
                    f23 = f2 * f0;
                    f24 = f6 * f4;
                    f0 = f3 * f0;
                    f4 = f7 * f4;
                    f25 = heapClassInst.heapFloat[r1 + numDefine149];
                    f26 = heapClassInst.heapFloat[r4 + numDefine11];
                    f27 = heapClassInst.heapFloat[r4 + numDefine7];
                    f28 = heapClassInst.heapFloat[r4 + numDefine3];
                    f9 = heapClassInst.heapFloat[fp + numDefineNeg3];
                    f29 = f9 * f8;
                    heapClassInst.heapFloat[fp + numDefineNeg8] = f29;
                    f30 = f13 * f12;
                    heapClassInst.heapFloat[fp + numDefineNeg10] = f30;
                    f9 = heapClassInst.heapFloat[fp + numDefineNeg2];
                    f9 = f9 * f8;
                    heapClassInst.heapFloat[fp + numDefineNeg9] = f9;
                    f9 = f14 * f12;
                    heapClassInst.heapFloat[fp + numDefineNeg12] = f9;
                    f9 = heapClassInst.heapFloat[fp + -1];
                    f8 = f9 * f8;
                    heapClassInst.heapFloat[fp + numDefineNeg11] = f8;
                    f9 = heapClassInst.heapFloat[fp + numDefineNeg7];
                    f12 = f9 * f12;
                    heapClassInst.heapFloat[fp + numDefineNeg13] = f12;
                    f8 = heapClassInst.heapFloat[r1 + numDefine165];
                    f9 = heapClassInst.heapFloat[r3 + numDefine11];
                    heapClassInst.heapFloat[fp + numDefineNeg4] = f9;
                    f9 = heapClassInst.heapFloat[r3 + numDefine7];
                    heapClassInst.heapFloat[fp + numDefineNeg6] = f9;
                    f9 = heapClassInst.heapFloat[r3 + numDefine3];
                    heapClassInst.heapFloat[fp + numDefineNeg5] = f9;
                    f9 = heapClassInst.heapFloat[r1 + numDefine145];
                    f12 = heapClassInst.heapFloat[r1 + numDefine144];
                    f29 = heapClassInst.heapFloat[r1 + numDefine143];
                    f30 = heapClassInst.heapFloat[r1 + numDefine161];
                    f21 = f21 + f22;
                    heapClassInst.heapFloat[fp + numDefineNeg15] = f21;
                    f22 = f26 * f25;
                    f21 = f23 + f24;
                    heapClassInst.heapFloat[fp + numDefineNeg16] = f21;
                    f23 = f27 * f25;
                    f0 = f0 + f4;
                    heapClassInst.heapFloat[fp + numDefineNeg14] = f0;
                    f0 = f28 * f25;
                    heapClassInst.heapFloat[fp + numDefineNeg23] = f0;
                    f0 = f10 * f1;
                    heapClassInst.heapFloat[fp + numDefineNeg24] = f0;
                    f4 = f11 * f5;
                    f21 = f15 * f1;
                    heapClassInst.heapFloat[fp + numDefineNeg18] = f21;
                    f24 = f16 * f5;
                    f1 = f17 * f1;
                    heapClassInst.heapFloat[fp + numDefineNeg20] = f1;
                    f5 = f18 * f5;
                    f25 = f10 * f2;
                    heapClassInst.heapFloat[fp + numDefineNeg17] = f25;
                    f0 = f11 * f6;
                    f1 = f15 * f2;
                    heapClassInst.heapFloat[fp + numDefineNeg19] = f1;
                    f1 = f16 * f6;
                    heapClassInst.heapFloat[fp + numDefineNeg28] = f1;
                    f2 = f17 * f2;
                    heapClassInst.heapFloat[fp + numDefineNeg21] = f2;
                    f1 = f18 * f6;
                    heapClassInst.heapFloat[fp + numDefineNeg29] = f1;
                    f2 = f10 * f3;
                    heapClassInst.heapFloat[fp + numDefineNeg25] = f2;
                    f6 = f11 * f7;
                    f10 = f15 * f3;
                    heapClassInst.heapFloat[fp + numDefineNeg26] = f10;
                    f11 = f16 * f7;
                    f3 = f17 * f3;
                    heapClassInst.heapFloat[fp + numDefineNeg22] = f3;
                    f7 = f18 * f7;
                    f15 = heapClassInst.heapFloat[fp + numDefineNeg8];
                    f16 = heapClassInst.heapFloat[fp + numDefineNeg10];
                    f15 = f15 + f16;
                    heapClassInst.heapFloat[fp + numDefineNeg27] = f15;
                    f16 = heapClassInst.heapFloat[fp + numDefineNeg4];
                    f17 = f16 * f8;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg9];
                    f21 = heapClassInst.heapFloat[fp + numDefineNeg12];
                    f18 = f18 + f21;
                    heapClassInst.heapFloat[fp + numDefineNeg8] = f18;
                    f21 = heapClassInst.heapFloat[fp + numDefineNeg6];
                    f25 = f21 * f8;
                    f1 = heapClassInst.heapFloat[fp + numDefineNeg11];
                    f2 = heapClassInst.heapFloat[fp + numDefineNeg13];
                    f1 = f1 + f2;
                    heapClassInst.heapFloat[fp + numDefineNeg9] = f1;
                    f2 = heapClassInst.heapFloat[fp + numDefineNeg5];
                    f1 = f2 * f8;
                    heapClassInst.heapFloat[fp + numDefineNeg11] = f1;
                    f2 = heapClassInst.heapFloat[fp + numDefineNeg3];
                    f2 = f19 * f2;
                    heapClassInst.heapFloat[fp + numDefineNeg3] = f2;
                    f1 = f20 * f13;
                    heapClassInst.heapFloat[fp + numDefineNeg12] = f1;
                    f2 = heapClassInst.heapFloat[fp + numDefineNeg2];
                    f2 = f19 * f2;
                    heapClassInst.heapFloat[fp + numDefineNeg10] = f2;
                    f1 = f20 * f14;
                    heapClassInst.heapFloat[fp + numDefineNeg13] = f1;
                    f2 = heapClassInst.heapFloat[fp + -1];
                    f2 = f19 * f2;
                    heapClassInst.heapFloat[fp + numDefineNeg2] = f2;
                    f3 = heapClassInst.heapFloat[fp + numDefineNeg7];
                    f1 = f20 * f3;
                    heapClassInst.heapFloat[fp + numDefineNeg30] = f1;
                    r5 = r2 >> numDefine2;
                    f2 = heapClassInst.heapFloat[r4 + numDefine15];
                    f3 = heapClassInst.heapFloat[fp + numDefineNeg15];
                    f3 = f3 + f22;
                    heapClassInst.heapFloat[fp + numDefineNeg7] = f3;
                    f8 = heapClassInst.heapFloat[r4 + numDefine14];
                    f10 = heapClassInst.heapFloat[fp + numDefineNeg16];
                    f1 = f10 + f23;
                    heapClassInst.heapFloat[fp + numDefineNeg15] = f1;
                    f1 = heapClassInst.heapFloat[r4 + numDefine13];
                    heapClassInst.heapFloat[fp + -1] = f1;
                    f3 = heapClassInst.heapFloat[fp + numDefineNeg14];
                    f10 = heapClassInst.heapFloat[fp + numDefineNeg23];
                    f3 = f3 + f10;
                    heapClassInst.heapFloat[fp + numDefineNeg16] = f3;
                    f10 = heapClassInst.heapFloat[fp + numDefineNeg24];
                    f4 = f10 + f4;
                    heapClassInst.heapFloat[fp + numDefineNeg14] = f4;
                    f1 = f9 * f26;
                    heapClassInst.heapFloat[fp + numDefineNeg23] = f1;
                    f3 = heapClassInst.heapFloat[fp + numDefineNeg18];
                    f1 = f3 + f24;
                    heapClassInst.heapFloat[fp + numDefineNeg18] = f1;
                    f3 = f12 * f26;
                    f4 = heapClassInst.heapFloat[fp + numDefineNeg20];
                    f4 = f4 + f5;
                    f5 = f29 * f26;
                    f10 = heapClassInst.heapFloat[fp + numDefineNeg17];
                    f0 = f10 + f0;
                    f10 = f9 * f27;
                    f13 = heapClassInst.heapFloat[fp + numDefineNeg19];
                    f14 = heapClassInst.heapFloat[fp + numDefineNeg28];
                    f13 = f13 + f14;
                    f14 = f12 * f27;
                    f15 = heapClassInst.heapFloat[fp + numDefineNeg21];
                    f16 = heapClassInst.heapFloat[fp + numDefineNeg29];
                    f15 = f15 + f16;
                    f16 = f29 * f27;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg25];
                    f6 = f18 + f6;
                    f9 = f9 * f28;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg26];
                    f11 = f18 + f11;
                    f12 = f12 * f28;
                    f18 = heapClassInst.heapFloat[fp + numDefineNeg22];
                    f7 = f18 + f7;
                    f18 = f29 * f28;
                    f19 = heapClassInst.heapFloat[fp + numDefineNeg27];
                    f17 = f19 + f17;
                    f19 = heapClassInst.heapFloat[r3 + numDefine15];
                    f20 = heapClassInst.heapFloat[fp + numDefineNeg8];
                    f20 = f20 + f25;
                    f21 = heapClassInst.heapFloat[r3 + numDefine14];
                    f22 = heapClassInst.heapFloat[fp + numDefineNeg9];
                    f23 = heapClassInst.heapFloat[fp + numDefineNeg11];
                    f22 = f22 + f23;
                    f23 = heapClassInst.heapFloat[r3 + numDefine13];
                    f24 = heapClassInst.heapFloat[fp + numDefineNeg3];
                    f25 = heapClassInst.heapFloat[fp + numDefineNeg12];
                    f24 = f24 + f25;
                    f25 = heapClassInst.heapFloat[fp + numDefineNeg4];
                    f25 = f30 * f25;
                    f26 = heapClassInst.heapFloat[fp + numDefineNeg10];
                    f27 = heapClassInst.heapFloat[fp + numDefineNeg13];
                    f26 = f26 + f27;
                    f27 = heapClassInst.heapFloat[fp + numDefineNeg6];
                    f27 = f30 * f27;
                    f28 = heapClassInst.heapFloat[fp + numDefineNeg2];
                    f29 = heapClassInst.heapFloat[fp + numDefineNeg30];
                    f28 = f28 + f29;
                    f29 = heapClassInst.heapFloat[fp + numDefineNeg5];
                    f29 = f30 * f29;
                    r6 = heapClassInst.heap32[r5 + numDefine6];
                    f30 = heapClassInst.heapFloat[fp + numDefineNeg7];
                    f30 = f30 + f2;
                    heapClassInst.heapFloat[fp + numDefineNeg2] = f30;
                    f30 = heapClassInst.heapFloat[fp + numDefineNeg15];
                    f30 = f30 + f8;
                    heapClassInst.heapFloat[fp + numDefineNeg3] = f30;
                    f30 = heapClassInst.heapFloat[fp + numDefineNeg16];
                    f1 = heapClassInst.heapFloat[fp + -1];
                    f1 = f30 + f1;
                    heapClassInst.heapFloat[fp + numDefineNeg4] = f1;
                    f1 = heapClassInst.heapFloat[fp + numDefineNeg14];
                    f30 = heapClassInst.heapFloat[fp + numDefineNeg23];
                    f1 = f1 + f30;
                    f30 = heapClassInst.heapFloat[fp + numDefineNeg18];
                    f3 = f30 + f3;
                    f4 = f4 + f5;
                    f0 = f0 + f10;
                    f5 = f13 + f14;
                    f10 = f15 + f16;
                    f6 = f6 + f9;
                    f9 = f11 + f12;
                    f7 = f7 + f18;
                    f11 = f17 + f19;
                    f12 = f20 + f21;
                    f13 = f22 + f23;
                    f14 = f24 + f25;
                    f15 = f26 + f27;
                    f16 = f28 + f29;
                    r7 = heapClassInst.heapU8[r0 + numDefine720];
                    if (r7 == 0) {
                        r7 = heapClassInst.heap32[r5 + numDefine2];
                        r7 = r7 >> numDefine2;
                        heapClassInst.heap32[r7] = numDefine53216;
                        r7 = r6 << numDefine2;
                        r8 = heapClassInst.heap32[r5 + numDefine2];
                        r7 = (r7 + r8) | 0;
                        r7 = r7 >> numDefine2;
                        heapClassInst.heap32[r7 + 1] = numDefine53216;
                        r7 = r6 << numDefine3;
                        r8 = heapClassInst.heap32[r5 + numDefine2];
                        r7 = (r7 + r8) | 0;
                        r7 = r7 >> numDefine2;
                        heapClassInst.heap32[r7 + numDefine2] = numDefine53216;
                        f2 = heapClassInst.heapFloat[r4 + numDefine15];
                        f8 = heapClassInst.heapFloat[r4 + numDefine14];
                        f17 = heapClassInst.heapFloat[r4 + numDefine13];
                        heapClassInst.heapFloat[fp + -1] = f17;
                    }
                    r7 = heapClassInst.heap32[r5 + numDefine3];
                    r8 = r7 >> numDefine2;
                    f17 = heapClassInst.heapFloat[fp + numDefineNeg3];
                    f8 = f17 - f8;
                    f17 = heapClassInst.heapFloat[fp + numDefineNeg2];
                    f2 = f17 - f2;
                    heapClassInst.heap32[r8] = 0;
                    r9 = (r6 + 1) | 0;
                    r10 = r6 << numDefine2;
                    f17 = -f8;
                    heapClassInst.heapFloat[r8 + 1] = f2;
                    r11 = (r6 + numDefine2) | 0;
                    r9 = r9 << numDefine2;
                    r12 = (r7 + r10) | 0;
                    heapClassInst.heapFloat[r8 + numDefine2] = f17;
                    r13 = (r6 + numDefine3) | 0;
                    r11 = r11 << numDefine2;
                    r14 = (r7 + r9) | 0;
                    r12 = r12 >> numDefine2;
                    f2 = -f2;
                    heapClassInst.heap32[r8 + numDefine3] = 0;
                    r8 = r13 << numDefine2;
                    r13 = (r7 + r11) | 0;
                    r14 = r14 >> numDefine2;
                    heapClassInst.heapFloat[r12] = f2;
                    r12 = r6 << numDefine3;
                    r15 = (r7 + r8) | 0;
                    f17 = heapClassInst.heapFloat[fp + numDefineNeg4];
                    f2 = heapClassInst.heapFloat[fp + -1];
                    f2 = f17 - f2;
                    r13 = r13 >> numDefine2;
                    heapClassInst.heap32[r14] = 0;
                    r14 = r12 | numDefine4;
                    r16 = (r7 + r12) | 0;
                    r15 = r15 >> numDefine2;
                    heapClassInst.heapFloat[r13] = f2;
                    r13 = (r12 + numDefine8) | 0;
                    r17 = (r7 + r14) | 0;
                    r16 = r16 >> numDefine2;
                    heapClassInst.heap32[r15] = 0;
                    r15 = (r12 + numDefine12) | 0;
                    r18 = (r7 + r13) | 0;
                    r17 = r17 >> numDefine2;
                    f2 = -f2;
                    heapClassInst.heapFloat[r16] = f8;
                    r7 = (r7 + r15) | 0;
                    r16 = r18 >> numDefine2;
                    heapClassInst.heapFloat[r17] = f2;
                    r7 = r7 >> numDefine2;
                    heapClassInst.heap32[r16] = 0;
                    heapClassInst.heap32[r7] = 0;
                    r7 = heapClassInst.heap32[r5 + numDefine5];
                    f2 = heapClassInst.heapFloat[r3 + numDefine15];
                    f8 = heapClassInst.heapFloat[r3 + numDefine14];
                    f17 = heapClassInst.heapFloat[r3 + numDefine13];
                    f2 = f11 - f2;
                    r16 = r7 >> numDefine2;
                    f18 = -f2;
                    heapClassInst.heap32[r16] = 0;
                    f8 = f12 - f8;
                    heapClassInst.heapFloat[r16 + 1] = f18;
                    r17 = (r7 + r10) | 0;
                    heapClassInst.heapFloat[r16 + numDefine2] = f8;
                    r9 = (r7 + r9) | 0;
                    r17 = r17 >> numDefine2;
                    heapClassInst.heap32[r16 + numDefine3] = 0;
                    f17 = f13 - f17;
                    r11 = (r7 + r11) | 0;
                    r9 = r9 >> numDefine2;
                    heapClassInst.heapFloat[r17] = f2;
                    r8 = (r7 + r8) | 0;
                    r11 = r11 >> numDefine2;
                    f2 = -f17;
                    heapClassInst.heap32[r9] = 0;
                    r9 = (r7 + r12) | 0;
                    r8 = r8 >> numDefine2;
                    heapClassInst.heapFloat[r11] = f2;
                    r11 = (r7 + r14) | 0;
                    r9 = r9 >> numDefine2;
                    f2 = -f8;
                    heapClassInst.heap32[r8] = 0;
                    r8 = (r7 + r13) | 0;
                    r11 = r11 >> numDefine2;
                    heapClassInst.heapFloat[r9] = f2;
                    r7 = (r7 + r15) | 0;
                    r8 = r8 >> numDefine2;
                    heapClassInst.heapFloat[r11] = f17;
                    r7 = r7 >> numDefine2;
                    heapClassInst.heap32[r8] = 0;
                    heapClassInst.heap32[r7] = 0;
                    f2 = heapClassInst.heapFloat[r5];
                    f8 = heapClassInst.heapFloat[r5 + 1];
                    f2 = f2 * f8;
                    r7 = heapClassInst.heapU8[r0 + numDefine720];
                    if (!(r7 != 0)) {
                        r6 = r6 << 1;
                        r7 = heapClassInst.heap32[r5 + numDefine7];
                        f8 = heapClassInst.heapFloat[fp + numDefineNeg4];
                        f8 = f13 - f8;
                        r7 = r7 >> numDefine2;
                        f8 = f8 * f2;
                        heapClassInst.heapFloat[r7] = f8;
                        r7 = heapClassInst.heap32[r5 + numDefine7];
                        r7 = (r7 + r10) | 0;
                        f8 = heapClassInst.heapFloat[fp + numDefineNeg3];
                        f8 = f12 - f8;
                        r7 = r7 >> numDefine2;
                        f8 = f8 * f2;
                        heapClassInst.heapFloat[r7] = f8;
                        r6 = r6 << numDefine2;
                        r7 = heapClassInst.heap32[r5 + numDefine7];
                        r6 = (r7 + r6) | 0;
                        f8 = heapClassInst.heapFloat[fp + numDefineNeg2];
                        f8 = f11 - f8;
                        r6 = r6 >> numDefine2;
                        f8 = f8 * f2;
                        heapClassInst.heapFloat[r6] = f8;
                    }
                    r2 = (r2 + numDefine4) | 0;
                    r6 = heapClassInst.heap32[r5 + numDefine6];
                    r7 = (r6 * numDefine3) | 0;
                    r8 = heapClassInst.heap32[r5 + numDefine3];
                    r9 = r7 << numDefine2;
                    r8 = (r8 + r9) | 0;
                    r8 = r8 >> numDefine2;
                    r10 = (r7 + 1) | 0;
                    heapClassInst.heapFloat[r8] = f7;
                    r8 = r10 << numDefine2;
                    r10 = heapClassInst.heap32[r5 + numDefine3];
                    r10 = (r10 + r8) | 0;
                    r10 = r10 >> numDefine2;
                    r7 = (r7 + numDefine2) | 0;
                    heapClassInst.heapFloat[r10] = f10;
                    r7 = r7 << numDefine2;
                    r10 = heapClassInst.heap32[r5 + numDefine3];
                    r10 = (r10 + r7) | 0;
                    r10 = r10 >> numDefine2;
                    heapClassInst.heapFloat[r10] = f4;
                    r6 = r6 << numDefine4;
                    r10 = heapClassInst.heap32[r5 + numDefine3];
                    r10 = (r10 + r6) | 0;
                    r10 = r10 >> numDefine2;
                    heapClassInst.heapFloat[r10] = f9;
                    r10 = r6 | numDefine4;
                    r11 = heapClassInst.heap32[r5 + numDefine3];
                    r11 = (r11 + r10) | 0;
                    r11 = r11 >> numDefine2;
                    heapClassInst.heapFloat[r11] = f5;
                    r11 = r6 | numDefine8;
                    r12 = heapClassInst.heap32[r5 + numDefine3];
                    r12 = (r12 + r11) | 0;
                    r12 = r12 >> numDefine2;
                    heapClassInst.heapFloat[r12] = f3;
                    r12 = heapClassInst.heap32[r5 + numDefine5];
                    r12 = (r12 + r9) | 0;
                    r12 = r12 >> numDefine2;
                    f8 = -f7;
                    heapClassInst.heapFloat[r12] = f8;
                    r12 = heapClassInst.heap32[r5 + numDefine5];
                    r8 = (r12 + r8) | 0;
                    r8 = r8 >> numDefine2;
                    f8 = -f10;
                    heapClassInst.heapFloat[r8] = f8;
                    r8 = heapClassInst.heap32[r5 + numDefine5];
                    r7 = (r8 + r7) | 0;
                    r7 = r7 >> numDefine2;
                    f8 = -f4;
                    heapClassInst.heapFloat[r7] = f8;
                    r7 = heapClassInst.heap32[r5 + numDefine5];
                    r7 = (r7 + r6) | 0;
                    r7 = r7 >> numDefine2;
                    f8 = -f9;
                    heapClassInst.heapFloat[r7] = f8;
                    r7 = heapClassInst.heap32[r5 + numDefine5];
                    r7 = (r7 + r10) | 0;
                    r7 = r7 >> numDefine2;
                    f8 = -f5;
                    heapClassInst.heapFloat[r7] = f8;
                    r7 = heapClassInst.heap32[r5 + numDefine5];
                    r7 = (r7 + r11) | 0;
                    f8 = f0 * f14;
                    f11 = f1 * f15;
                    f12 = f1 * f16;
                    f13 = f6 * f14;
                    f8 = f8 - f11;
                    f11 = f12 - f13;
                    f12 = f6 * f15;
                    f13 = f0 * f16;
                    r7 = r7 >> numDefine2;
                    f14 = -f3;
                    f12 = f12 - f13;
                    heapClassInst.heapFloat[r7] = f14;
                    f7 = f8 * f7;
                    f10 = f11 * f10;
                    r7 = heapClassInst.heap32[r5 + numDefine7];
                    f7 = f7 + f10;
                    f4 = f12 * f4;
                    r7 = (r7 + r9) | 0;
                    f4 = f7 + f4;
                    r7 = r7 >> numDefine2;
                    f4 = f4 * f2;
                    heapClassInst.heapFloat[r7] = f4;
                    f4 = f8 * f9;
                    f5 = f11 * f5;
                    r7 = heapClassInst.heap32[r5 + numDefine7];
                    f4 = f4 + f5;
                    f3 = f12 * f3;
                    r6 = (r7 + r6) | 0;
                    f3 = f4 + f3;
                    r6 = r6 >> numDefine2;
                    f2 = f3 * f2;
                    heapClassInst.heapFloat[r6] = f2;
                    r6 = heapClassInst.heapU8[r0 + numDefine722];
                    if (r6 != 0) {
                        f2 = heapClassInst.heapFloat[r1 + numDefine176];
                        f3 = heapClassInst.heapFloat[r1 + numDefine179];
                        f2 = f2 * f3;
                        f3 = 0;
                        r6 = 1;
                        r7 = numDefine2;
                        r6 = f2 > f3 ? r6 : r7;
                    } else {
                        f2 = 0;
                        r6 = 0;
                    }
                    r7 = heapClassInst.heapU8[r0 + numDefine721];
                    r8 = 0;

                    r9 = r7 != r8 ? 1 : 0;
                    r9 = r9 & 1;
                    r9 = r9 | r6;
                    if (r9 == 0) {
                        label = numDefine54;
                        break repeat1;
                    } else {
                        r9 = heapClassInst.heap32[r5 + numDefine6];
                        r9 = (r9 * numDefine5) | 0;
                        r10 = heapClassInst.heap32[r5 + numDefine3];
                        r11 = r9 << numDefine2;
                        r10 = (r10 + r11) | 0;
                        r10 = r10 >> numDefine2;
                        r12 = (r9 + 1) | 0;
                        heapClassInst.heapFloat[r10] = f6;
                        r10 = r12 << numDefine2;
                        r12 = heapClassInst.heap32[r5 + numDefine3];
                        r12 = (r12 + r10) | 0;
                        r12 = r12 >> numDefine2;
                        r9 = (r9 + numDefine2) | 0;
                        heapClassInst.heapFloat[r12] = f0;
                        r9 = r9 << numDefine2;
                        r12 = heapClassInst.heap32[r5 + numDefine3];
                        r12 = (r12 + r9) | 0;
                        r12 = r12 >> numDefine2;
                        heapClassInst.heapFloat[r12] = f1;
                        r12 = heapClassInst.heap32[r5 + numDefine5];
                        r12 = (r12 + r11) | 0;
                        r12 = r12 >> numDefine2;
                        f3 = -f6;
                        heapClassInst.heapFloat[r12] = f3;
                        r12 = heapClassInst.heap32[r5 + numDefine5];
                        r10 = (r12 + r10) | 0;
                        r10 = r10 >> numDefine2;
                        f3 = -f0;
                        heapClassInst.heapFloat[r10] = f3;
                        r10 = heapClassInst.heap32[r5 + numDefine5];
                        r9 = (r10 + r9) | 0;
                        r9 = r9 >> numDefine2;
                        f3 = -f1;
                        heapClassInst.heapFloat[r9] = f3;
                        r9 = heapClassInst.heap32[r5 + numDefine7];
                        r9 = (r9 + r11) | 0;
                        f3 = heapClassInst.heapFloat[r1 + numDefine172];
                        f4 = heapClassInst.heapFloat[r1 + numDefine173];
                        r9 = r9 >> numDefine2;
                        heapClassInst.heap32[r9] = 0;

                        r9 = r6 != r8 ? 1 : 0;
                        r10 = f3 == f4 ? 1 : 0;

                        r12 = heapClassInst.heap32[r1 + numDefine183];
                        r9 = r9 & r10;
                        r10 = r12 & numDefine2;
                        if (r10 != 0) {
                            r2 = (r0 + numDefine744) | 0;
                        }
                        r2 = r2 >> numDefine2;
                        f5 = heapClassInst.heapFloat[r2];

                        r2 = r7 == r8 ? 1 : 0;
                        r2 = r9 | r2;
                        if (!(r2 != 0)) {
                            r2 = r12 & numDefine4;
                            if (!(r2 == 0)) {
                                r2 = heapClassInst.heap32[r5 + numDefine8];
                                r2 = (r2 + r11) | 0;
                                r2 = r2 >> numDefine2;
                                heapClassInst.heap32[r2] = heapClassInst.heap32[r1 + numDefine184];
                            }
                            f7 = 1;
                            f8 = 0;
                            f9 = heapClassInst.heapFloat[r1 + numDefine167];
                            repeat24: do {
                                if (f3 < f4) {
                                    f10 = heapClassInst.heapFloat[r1 + numDefine178];
                                    f11 = heapClassInst.heapFloat[r5];
                                    f11 = f11 * f5;
                                    f11 = f9 / f11;
                                    if (f11 >= f8) {
                                        if (f11 > f8) {
                                            if (!(f10 > f4)) {
                                                f8 = f4 - f11;
                                                if (!(f8 >= f10)) {
                                                    f7 = f4 - f10;
                                                    f8 = f7 / f11;
                                                    break repeat24;
                                                }
                                            }
                                            f8 = 0;
                                            f8 = f10 > f4 ? f8 : f7;
                                        } else {
                                            break repeat24;
                                        }
                                    } else {
                                        if (!(f10 < f3)) {
                                            f8 = f3 - f11;
                                            if (!(f8 <= f10)) {
                                                f7 = f3 - f10;
                                                f8 = f7 / f11;
                                                break repeat24;
                                            }
                                        }
                                        f8 = 0;
                                        f8 = f10 < f3 ? f8 : f7;
                                    }
                                } else {
                                    f8 = f3 > f4 ? f7 : f8;
                                }
                            } while (false);
                            r2 = heapClassInst.heap32[r5 + numDefine7];
                            r2 = (r2 + r11) | 0;
                            r2 = r2 >> numDefine2;
                            f7 = f9 * f8;
                            f8 = heapClassInst.heapFloat[r1 + numDefine179];
                            f9 = heapClassInst.heapFloat[r2];
                            f7 = f7 * f8;
                            f7 = f9 + f7;
                            heapClassInst.heapFloat[r2] = f7;
                            r2 = heapClassInst.heap32[r5 + numDefine9];
                            f7 = heapClassInst.heapFloat[r1 + numDefine168];
                            r2 = (r2 + r11) | 0;
                            r2 = r2 >> numDefine2;
                            f7 = -f7;
                            heapClassInst.heapFloat[r2] = f7;
                            r2 = heapClassInst.heap32[r5 + numDefine10];
                            r2 = (r2 + r11) | 0;
                            r2 = r2 >> numDefine2;
                            heapClassInst.heap32[r2] = heapClassInst.heap32[r1 + numDefine168];
                        }
                        if (r6 == 0) {
                            label = numDefine54;
                            break repeat1;
                        } else {
                            r2 = heapClassInst.heap32[r5 + numDefine7];
                            r2 = (r2 + r11) | 0;
                            f7 = heapClassInst.heapFloat[r5];
                            r2 = r2 >> numDefine2;
                            f5 = f7 * f5;
                            f7 = heapClassInst.heapFloat[r2];
                            f2 = f5 * f2;
                            f2 = f7 + f2;
                            heapClassInst.heapFloat[r2] = f2;
                            r0 = heapClassInst.heapU8[r0 + numDefine732];
                            r0 = r0 & 1;
                            if (!(r0 == 0)) {
                                r0 = heapClassInst.heap32[r5 + numDefine8];
                                r0 = (r0 + r11) | 0;
                                r0 = r0 >> numDefine2;
                                heapClassInst.heap32[r0] = heapClassInst.heap32[r1 + numDefine185];
                            }
                            if (f3 != f4) {
                                r0 = heapClassInst.heap32[r5 + numDefine9];
                                if (r6 != 1) {
                                    r0 = (r0 + r11) | 0;
                                    r0 = r0 >> numDefine2;
                                    heapClassInst.heap32[r0] = numDefineNeg88609;
                                    r0 = heapClassInst.heap32[r5 + numDefine10];
                                    r0 = (r0 + r11) | 0;
                                    r0 = r0 >> numDefine2;
                                    heapClassInst.heap32[r0] = 0;
                                } else {
                                    r0 = (r0 + r11) | 0;
                                    r0 = r0 >> numDefine2;
                                    heapClassInst.heap32[r0] = 0;
                                    r0 = heapClassInst.heap32[r5 + numDefine10];
                                    r0 = (r0 + r11) | 0;
                                    r0 = r0 >> numDefine2;
                                    heapClassInst.heap32[r0] = numDefine95039;
                                }
                            } else {
                                r0 = heapClassInst.heap32[r5 + numDefine9];
                                r0 = (r0 + r11) | 0;
                                r0 = r0 >> numDefine2;
                                heapClassInst.heap32[r0] = numDefineNeg88609;
                                r0 = heapClassInst.heap32[r5 + numDefine10];
                                r0 = (r0 + r11) | 0;
                                r0 = r0 >> numDefine2;
                                heapClassInst.heap32[r0] = numDefine95039;
                            }
                            f2 = heapClassInst.heapFloat[r1 + numDefine171];
                            f3 = 0;
                            if (f2 <= f3) {
                                label = numDefine53;
                                break repeat1;
                            } else {
                                f4 = heapClassInst.heapFloat[r4 + numDefine80];
                                f5 = heapClassInst.heapFloat[r3 + numDefine80];
                                f7 = heapClassInst.heapFloat[r4 + numDefine81];
                                f8 = heapClassInst.heapFloat[r3 + numDefine81];
                                f4 = f4 * f6;
                                f7 = f7 * f0;
                                f9 = heapClassInst.heapFloat[r4 + numDefine82];
                                f10 = heapClassInst.heapFloat[r3 + numDefine82];
                                f5 = f5 * f6;
                                f0 = f8 * f0;
                                f4 = f4 + f7;
                                f6 = f9 * f1;
                                f0 = f5 + f0;
                                f1 = f10 * f1;
                                f4 = f4 + f6;
                                f0 = f0 + f1;
                                f0 = f4 - f0;
                                if (r6 != 1) {
                                    if (f0 <= f3) {
                                        label = numDefine53;
                                        break repeat1;
                                    } else {
                                        r0 = heapClassInst.heap32[r5 + numDefine7];
                                        f1 = -f2;
                                        r0 = (r0 + r11) | 0;
                                        f0 = f0 * f1;
                                        r0 = r0 >> numDefine2;
                                        f1 = heapClassInst.heapFloat[r0];
                                        if (f1 <= f0) {
                                            label = numDefine53;
                                            break repeat1;
                                        } else {
                                            heapClassInst.heapFloat[r0] = f0;
                                            label = numDefine53;
                                            break repeat1;
                                        }
                                    }
                                } else {
                                    if (f0 >= f3) {
                                        label = numDefine53;
                                        break repeat1;
                                    } else {
                                        r0 = heapClassInst.heap32[r5 + numDefine7];
                                        f2 = -f2;
                                        r0 = (r0 + r11) | 0;
                                        f0 = f0 * f2;
                                        r0 = r0 >> numDefine2;
                                        f2 = heapClassInst.heapFloat[r0];
                                        if (f2 >= f0) {
                                            label = numDefine53;
                                            break repeat1;
                                        } else {
                                            heapClassInst.heapFloat[r0] = f0;
                                            label = numDefine53;
                                            break repeat1;
                                        }
                                    }
                                }
                            }
                        }
                    }
                } else {
                    r0 = twoEStr1149;
                    r1 = twoEStr231;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine331;
                    assertNew(i7);
                }
            } else {
                r5 = r5 & numDefine255;
                if (r5 == 0) {
                    r4 = r4 >> numDefine2;
                    r3 = r3 >> numDefine2;
                    f0 = heapClassInst.heapFloat[r3 + numDefine9];
                    heapClassInst.heapFloat[fp + numDefineNeg5] = f0;
                    f1 = heapClassInst.heapFloat[r1 + numDefine163];
                    f0 = heapClassInst.heapFloat[r3 + numDefine5];
                    heapClassInst.heapFloat[fp + numDefineNeg6] = f0;
                    f2 = heapClassInst.heapFloat[r3 + 1];
                    heapClassInst.heapFloat[fp + numDefineNeg4] = f2;
                    f0 = heapClassInst.heapFloat[r3 + numDefine10];
                    heapClassInst.heapFloat[fp + numDefineNeg7] = f0;
                    f2 = heapClassInst.heapFloat[r1 + numDefine164];
                    f0 = heapClassInst.heapFloat[r3 + numDefine6];
                    heapClassInst.heapFloat[fp + numDefineNeg8] = f0;
                    f3 = heapClassInst.heapFloat[r3 + numDefine2];
                    heapClassInst.heapFloat[fp + numDefineNeg9] = f3;
                    f4 = heapClassInst.heapFloat[r4 + numDefine9];
                    f5 = heapClassInst.heapFloat[r1 + numDefine147];
                    f6 = heapClassInst.heapFloat[r4 + numDefine5];
                    f7 = heapClassInst.heapFloat[r4 + 1];
                    f8 = heapClassInst.heapFloat[r4 + numDefine10];
                    f9 = heapClassInst.heapFloat[r1 + numDefine148];
                    f10 = heapClassInst.heapFloat[r4 + numDefine6];
                    f11 = heapClassInst.heapFloat[r4 + numDefine2];
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg5];
                    f12 = f0 * f1;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg7];
                    f13 = f0 * f2;
                    f14 = heapClassInst.heapFloat[r3 + numDefine11];
                    heapClassInst.heapFloat[fp + numDefineNeg2] = f14;
                    f15 = heapClassInst.heapFloat[r1 + numDefine165];
                    f16 = heapClassInst.heapFloat[r3 + numDefine7];
                    heapClassInst.heapFloat[fp + numDefineNeg3] = f16;
                    f17 = heapClassInst.heapFloat[r3 + numDefine3];
                    heapClassInst.heapFloat[fp + -1] = f17;
                    f18 = f4 * f5;
                    f19 = f8 * f9;
                    f20 = heapClassInst.heapFloat[r4 + numDefine11];
                    f21 = heapClassInst.heapFloat[r1 + numDefine149];
                    f22 = heapClassInst.heapFloat[r4 + numDefine7];
                    f23 = heapClassInst.heapFloat[r4 + numDefine3];
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg6];
                    f24 = f0 * f1;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg8];
                    f25 = f0 * f2;
                    f26 = f6 * f5;
                    f27 = f10 * f9;
                    f28 = heapClassInst.heapFloat[fp + numDefineNeg4];
                    f1 = f28 * f1;
                    f2 = f3 * f2;
                    f5 = f7 * f5;
                    f9 = f11 * f9;
                    f29 = heapClassInst.heapFloat[r1 + numDefine137];
                    f30 = heapClassInst.heapFloat[r1 + numDefine141];
                    f0 = heapClassInst.heapFloat[r1 + numDefine136];
                    f3 = heapClassInst.heapFloat[r1 + numDefine140];
                    f14 = heapClassInst.heapFloat[r1 + numDefine153];
                    f16 = heapClassInst.heapFloat[r1 + numDefine157];
                    f12 = f12 + f13;
                    heapClassInst.heapFloat[fp + numDefineNeg14] = f12;
                    f13 = heapClassInst.heapFloat[fp + numDefineNeg2];
                    f17 = f13 * f15;
                    f18 = f18 + f19;
                    f19 = f20 * f21;
                    f24 = f24 + f25;
                    f25 = heapClassInst.heapFloat[fp + numDefineNeg3];
                    f28 = f25 * f15;
                    f26 = f26 + f27;
                    f27 = f22 * f21;
                    f1 = f1 + f2;
                    heapClassInst.heapFloat[fp + numDefineNeg10] = f1;
                    f2 = heapClassInst.heapFloat[fp + -1];
                    f15 = f2 * f15;
                    f5 = f5 + f9;
                    heapClassInst.heapFloat[fp + numDefineNeg12] = f5;
                    f9 = f23 * f21;
                    f21 = heapClassInst.heapFloat[r1 + numDefine145];
                    f1 = heapClassInst.heapFloat[r1 + numDefine144];
                    f2 = heapClassInst.heapFloat[r1 + numDefine161];
                    f5 = heapClassInst.heapFloat[r3 + numDefine84];
                    f12 = heapClassInst.heapFloat[r4 + numDefine84];
                    f13 = (float) numDefineFloat1257;
                    heapClassInst.heapFloat[fp + numDefineNeg11] = f13;
                    f25 = f29 * f4;
                    heapClassInst.heapFloat[fp + numDefineNeg13] = f25;
                    f25 = f30 * f8;
                    f4 = f0 * f4;
                    heapClassInst.heapFloat[fp + numDefineNeg16] = f4;
                    f8 = f3 * f8;
                    f4 = f29 * f6;
                    heapClassInst.heapFloat[fp + numDefineNeg15] = f4;
                    f4 = f30 * f10;
                    f6 = f0 * f6;
                    heapClassInst.heapFloat[fp + numDefineNeg18] = f6;
                    f10 = f3 * f10;
                    f29 = f29 * f7;
                    f30 = f30 * f11;
                    f0 = f0 * f7;
                    heapClassInst.heapFloat[fp + numDefineNeg17] = f0;
                    f3 = f3 * f11;
                    f7 = heapClassInst.heapFloat[fp + numDefineNeg5];
                    f0 = f14 * f7;
                    heapClassInst.heapFloat[fp + numDefineNeg19] = f0;
                    f6 = heapClassInst.heapFloat[fp + numDefineNeg7];
                    f6 = f16 * f6;
                    f7 = heapClassInst.heapFloat[fp + numDefineNeg6];
                    f7 = f14 * f7;
                    heapClassInst.heapFloat[fp + numDefineNeg5] = f7;
                    f11 = heapClassInst.heapFloat[fp + numDefineNeg8];
                    f11 = f16 * f11;
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg4];
                    f0 = f14 * f0;
                    heapClassInst.heapFloat[fp + numDefineNeg4] = f0;
                    f14 = heapClassInst.heapFloat[fp + numDefineNeg9];
                    f14 = f16 * f14;
                    f16 = heapClassInst.heapFloat[fp + numDefineNeg14];
                    f16 = f16 + f17;
                    f17 = heapClassInst.heapFloat[r3 + numDefine15];
                    f18 = f18 + f19;
                    f19 = heapClassInst.heapFloat[r4 + numDefine15];
                    f24 = f24 + f28;
                    f28 = heapClassInst.heapFloat[r3 + numDefine14];
                    f26 = f26 + f27;
                    f27 = heapClassInst.heapFloat[r4 + numDefine14];
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg10];
                    f0 = f0 + f15;
                    f15 = heapClassInst.heapFloat[r3 + numDefine13];
                    f7 = heapClassInst.heapFloat[fp + numDefineNeg12];
                    f7 = f7 + f9;
                    f9 = heapClassInst.heapFloat[r4 + numDefine13];
                    r5 = r2 >> numDefine2;
                    f16 = f16 + f17;
                    f17 = f18 + f19;
                    f18 = f24 + f28;
                    f19 = f26 + f27;
                    f0 = f0 + f15;
                    f7 = f7 + f9;
                    f9 = heapClassInst.heapFloat[fp + numDefineNeg13];
                    f9 = f9 + f25;
                    f15 = f21 * f20;
                    f24 = heapClassInst.heapFloat[fp + numDefineNeg16];
                    f8 = f24 + f8;
                    f20 = f1 * f20;
                    f24 = heapClassInst.heapFloat[fp + numDefineNeg15];
                    f4 = f24 + f4;
                    f24 = f21 * f22;
                    f25 = heapClassInst.heapFloat[fp + numDefineNeg18];
                    f10 = f25 + f10;
                    f22 = f1 * f22;
                    f25 = f29 + f30;
                    f21 = f21 * f23;
                    f26 = heapClassInst.heapFloat[fp + numDefineNeg17];
                    f3 = f26 + f3;
                    f1 = f1 * f23;
                    f23 = heapClassInst.heapFloat[fp + numDefineNeg19];
                    f6 = f23 + f6;
                    f23 = heapClassInst.heapFloat[fp + numDefineNeg2];
                    f23 = f2 * f23;
                    f26 = heapClassInst.heapFloat[fp + numDefineNeg5];
                    f11 = f26 + f11;
                    f26 = heapClassInst.heapFloat[fp + numDefineNeg3];
                    f26 = f2 * f26;
                    f27 = heapClassInst.heapFloat[fp + numDefineNeg4];
                    f14 = f27 + f14;
                    f27 = heapClassInst.heapFloat[fp + -1];
                    f2 = f2 * f27;

                    r6 = f12 < f13 ? 1 : 0;
                    r7 = f5 < f13 ? 1 : 0;

                    f12 = f12 + f5;
                    r8 = heapClassInst.heap32[r5 + numDefine6];
                    f9 = f9 + f15;
                    heapClassInst.heapFloat[fp + numDefineNeg3] = f9;
                    f8 = f8 + f20;
                    f4 = f4 + f24;
                    heapClassInst.heapFloat[fp + numDefineNeg2] = f4;
                    f4 = f10 + f22;
                    f9 = f25 + f21;
                    heapClassInst.heapFloat[fp + numDefineNeg4] = f9;
                    f1 = f3 + f1;
                    f3 = f6 + f23;
                    heapClassInst.heapFloat[fp + numDefineNeg7] = f3;
                    f3 = f11 + f26;
                    heapClassInst.heapFloat[fp + numDefineNeg6] = f3;
                    f2 = f14 + f2;
                    heapClassInst.heapFloat[fp + numDefineNeg5] = f2;
                    f2 = f16 - f17;
                    heapClassInst.heapFloat[fp + numDefineNeg8] = f2;
                    f2 = f18 - f19;
                    heapClassInst.heapFloat[fp + numDefineNeg9] = f2;
                    f2 = f0 - f7;
                    heapClassInst.heapFloat[fp + numDefineNeg10] = f2;
                    r6 = r6 | r7;
                    f2 = 0;
                    if (f12 > f2) {
                        f5 = f5 / f12;
                    } else {
                        f5 = (float) numDefineFloat05;
                    }
                    f3 = 1;
                    heapClassInst.heapFloat[fp + -1] = f3;
                    f6 = f3 - f5;
                    f9 = heapClassInst.heapFloat[fp + numDefineNeg4];
                    f9 = f9 * f5;
                    f10 = heapClassInst.heapFloat[fp + numDefineNeg5];
                    f10 = f10 * f6;
                    f11 = heapClassInst.heapFloat[fp + numDefineNeg2];
                    f11 = f11 * f5;
                    f12 = heapClassInst.heapFloat[fp + numDefineNeg6];
                    f12 = f12 * f6;
                    f9 = f9 + f10;
                    f10 = f11 + f12;
                    f11 = heapClassInst.heapFloat[fp + numDefineNeg3];
                    f11 = f11 * f5;
                    f12 = heapClassInst.heapFloat[fp + numDefineNeg7];
                    f12 = f12 * f6;
                    f11 = f11 + f12;
                    f12 = f9 * f9;
                    f13 = f10 * f10;
                    f12 = f12 + f13;
                    f13 = f11 * f11;
                    f12 = f12 + f13;
                    heapClassInst.heapFloat[g0] = f12;
                    sqrtf(i7);
                    f3 = (float) (f3 / commonVariable.fg0);
                    f12 = heapClassInst.heapFloat[r3 + numDefine13];
                    f13 = heapClassInst.heapFloat[r3 + numDefine14];
                    f14 = heapClassInst.heapFloat[r4 + numDefine13];
                    f15 = heapClassInst.heapFloat[r4 + numDefine14];
                    f9 = f9 * f3;
                    f0 = f0 - f12;
                    f7 = f7 - f14;
                    f10 = f10 * f3;
                    f12 = f18 - f13;
                    f13 = f19 - f15;
                    f14 = heapClassInst.heapFloat[r3 + numDefine15];
                    f15 = heapClassInst.heapFloat[r4 + numDefine15];
                    f3 = f11 * f3;
                    f11 = f16 - f14;
                    f14 = f17 - f15;
                    f15 = f0 * f9;
                    f16 = f12 * f10;
                    f17 = f7 * f9;
                    f18 = f13 * f10;
                    f15 = f15 + f16;
                    f16 = f11 * f3;
                    f17 = f17 + f18;
                    f18 = f14 * f3;
                    f15 = f15 + f16;
                    f16 = f17 + f18;
                    f17 = f10 * f15;
                    f18 = f10 * f16;
                    f19 = f9 * f15;
                    f20 = f9 * f16;
                    f15 = f3 * f15;
                    f16 = f3 * f16;
                    f12 = f12 - f17;
                    f13 = f13 - f18;
                    f0 = f0 - f19;
                    f7 = f7 - f20;
                    f11 = f11 - f15;
                    f14 = f14 - f16;
                    f21 = f12 * f5;
                    f22 = f13 * f6;
                    f23 = f0 * f5;
                    f24 = f7 * f6;
                    f21 = f21 + f22;
                    f22 = f23 + f24;
                    f23 = f11 * f5;
                    f24 = f14 * f6;
                    f15 = f16 - f15;
                    f16 = f18 - f17;
                    f17 = f20 - f19;
                    f18 = f23 + f24;
                    f19 = f22 * f22;
                    f20 = f21 * f21;
                    f23 = f15 * f5;
                    f24 = f16 * f5;
                    f25 = f17 * f5;
                    f15 = f15 * f6;
                    f16 = f16 * f6;
                    f17 = f17 * f6;
                    f19 = f19 + f20;
                    f20 = f18 * f18;
                    f19 = f19 + f20;
                    r7 = r8 << 1;
                    f14 = f14 + f23;
                    f13 = f13 + f24;
                    f7 = f7 + f25;
                    f11 = f11 - f15;
                    f12 = f12 - f16;
                    f0 = f0 - f17;
                    f15 = heapClassInst.heapFloat[fp + numDefineNeg11];
                    if (f19 > f15) {
                        heapClassInst.heapFloat[g0] = f19;
                        sqrtf(i7);
                        f4 = heapClassInst.heapFloat[fp + -1];
                        f8 = (float) (f4 / commonVariable.fg0);
                        f1 = f22 * f8;
                        f4 = f21 * f8;
                        f8 = f18 * f8;
                    }
                    r9 = heapClassInst.heap32[r5 + numDefine3];
                    f15 = f13 * f8;
                    f16 = f14 * f4;
                    r9 = r9 >> numDefine2;
                    f15 = f15 - f16;
                    heapClassInst.heapFloat[r9] = f15;
                    r9 = heapClassInst.heap32[r5 + numDefine3];
                    f15 = f14 * f1;
                    f16 = f7 * f8;
                    r9 = r9 >> numDefine2;
                    f15 = f15 - f16;
                    heapClassInst.heapFloat[r9 + 1] = f15;
                    r9 = heapClassInst.heap32[r5 + numDefine3];
                    f15 = f7 * f4;
                    f16 = f13 * f1;
                    r9 = r9 >> numDefine2;
                    f15 = f15 - f16;
                    heapClassInst.heapFloat[r9 + numDefine2] = f15;
                    f15 = f12 * f8;
                    f16 = f11 * f4;
                    f15 = f15 - f16;
                    r9 = heapClassInst.heap32[r5 + numDefine5];
                    r9 = r9 >> numDefine2;
                    f15 = -f15;
                    heapClassInst.heapFloat[r9] = f15;
                    f15 = f11 * f1;
                    f16 = f0 * f8;
                    f15 = f15 - f16;
                    r9 = heapClassInst.heap32[r5 + numDefine5];
                    f16 = f10 * f8;
                    f17 = f3 * f4;
                    f18 = f9 * f4;
                    f19 = f10 * f1;
                    f20 = f3 * f1;
                    f21 = f9 * f8;
                    r9 = r9 >> numDefine2;
                    f15 = -f15;
                    f16 = f16 - f17;
                    f17 = f18 - f19;
                    f18 = f20 - f21;
                    heapClassInst.heapFloat[r9 + 1] = f15;
                    f15 = f0 * f4;
                    f19 = f12 * f1;
                    f15 = f15 - f19;
                    r9 = heapClassInst.heap32[r5 + numDefine5];
                    f19 = f7 * f18;
                    f20 = f13 * f16;
                    f21 = f14 * f16;
                    f22 = f7 * f17;
                    f23 = f13 * f17;
                    f24 = f14 * f18;
                    f25 = f0 * f18;
                    f26 = f12 * f16;
                    f27 = f11 * f16;
                    f28 = f0 * f17;
                    f29 = f12 * f17;
                    f30 = f11 * f18;
                    f19 = f19 - f20;
                    f20 = f21 - f22;
                    f21 = f23 - f24;
                    f22 = f25 - f26;
                    f23 = f27 - f28;
                    f24 = f29 - f30;
                    r9 = r9 >> numDefine2;
                    f15 = -f15;
                    heapClassInst.heapFloat[r9 + numDefine2] = f15;
                    if (r6 != 0) {
                        r9 = heapClassInst.heapU8[r0 + numDefine722];
                        if (!(r9 == 0)) {
                            f24 = f24 * f6;
                            f23 = f23 * f6;
                            f22 = f22 * f6;
                            f21 = f21 * f5;
                            f20 = f20 * f5;
                            f19 = f19 * f5;
                        }
                    }
                    r9 = r8 << numDefine2;
                    r10 = heapClassInst.heap32[r5 + numDefine3];
                    r10 = (r10 + r9) | 0;
                    r10 = r10 >> numDefine2;
                    r11 = (r8 + 1) | 0;
                    heapClassInst.heapFloat[r10] = f21;
                    r10 = r11 << numDefine2;
                    r11 = heapClassInst.heap32[r5 + numDefine3];
                    r11 = (r11 + r10) | 0;
                    r11 = r11 >> numDefine2;
                    r12 = (r8 + numDefine2) | 0;
                    heapClassInst.heapFloat[r11] = f20;
                    r11 = r12 << numDefine2;
                    r12 = heapClassInst.heap32[r5 + numDefine3];
                    r12 = (r12 + r11) | 0;
                    r12 = r12 >> numDefine2;
                    heapClassInst.heapFloat[r12] = f19;
                    r12 = heapClassInst.heap32[r5 + numDefine5];
                    r12 = (r12 + r9) | 0;
                    r12 = r12 >> numDefine2;
                    f15 = -f24;
                    heapClassInst.heapFloat[r12] = f15;
                    r12 = heapClassInst.heap32[r5 + numDefine5];
                    r10 = (r12 + r10) | 0;
                    r10 = r10 >> numDefine2;
                    f15 = -f23;
                    heapClassInst.heapFloat[r10] = f15;
                    r10 = heapClassInst.heap32[r5 + numDefine5];
                    r10 = (r10 + r11) | 0;
                    f15 = f7 * f10;
                    f19 = f13 * f9;
                    f20 = f14 * f9;
                    f7 = f7 * f3;
                    f13 = f13 * f3;
                    f14 = f14 * f10;
                    f21 = f0 * f10;
                    f23 = f12 * f9;
                    f24 = f11 * f9;
                    f0 = f0 * f3;
                    f12 = f12 * f3;
                    f11 = f11 * f10;
                    f15 = f15 - f19;
                    f7 = f20 - f7;
                    f13 = f13 - f14;
                    f14 = f21 - f23;
                    f0 = f24 - f0;
                    f11 = f12 - f11;
                    r10 = r10 >> numDefine2;
                    f12 = -f22;
                    heapClassInst.heapFloat[r10] = f12;
                    if (r6 != 0) {
                        f11 = f11 * f6;
                        f0 = f0 * f6;
                        f14 = f14 * f6;
                        f13 = f13 * f5;
                        f7 = f7 * f5;
                        f15 = f15 * f5;
                    }
                    r6 = r7 << numDefine2;
                    r10 = heapClassInst.heap32[r5 + numDefine3];
                    r10 = (r10 + r6) | 0;
                    r10 = r10 >> numDefine2;
                    r11 = r7 | 1;
                    heapClassInst.heapFloat[r10] = f13;
                    r10 = r11 << numDefine2;
                    r11 = heapClassInst.heap32[r5 + numDefine3];
                    r11 = (r11 + r10) | 0;
                    r11 = r11 >> numDefine2;
                    r7 = (r7 + numDefine2) | 0;
                    heapClassInst.heapFloat[r11] = f7;
                    r7 = r7 << numDefine2;
                    r11 = heapClassInst.heap32[r5 + numDefine3];
                    r11 = (r11 + r7) | 0;
                    r11 = r11 >> numDefine2;
                    heapClassInst.heapFloat[r11] = f15;
                    r11 = heapClassInst.heap32[r5 + numDefine5];
                    r11 = (r11 + r6) | 0;
                    r11 = r11 >> numDefine2;
                    f5 = -f11;
                    heapClassInst.heapFloat[r11] = f5;
                    r11 = heapClassInst.heap32[r5 + numDefine5];
                    r11 = (r11 + r10) | 0;
                    r11 = r11 >> numDefine2;
                    f0 = -f0;
                    heapClassInst.heapFloat[r11] = f0;
                    r11 = heapClassInst.heap32[r5 + numDefine5];
                    r7 = (r11 + r7) | 0;
                    r7 = r7 >> numDefine2;
                    f0 = -f14;
                    heapClassInst.heapFloat[r7] = f0;
                    r7 = heapClassInst.heapU8[r0 + numDefine720];
                    if (!(r7 != 0)) {
                        f0 = heapClassInst.heapFloat[r5];
                        f5 = heapClassInst.heapFloat[r5 + 1];
                        f0 = f0 * f5;
                        r7 = heapClassInst.heap32[r5 + numDefine2];
                        r7 = r7 >> numDefine2;
                        heapClassInst.heapFloat[r7] = f1;
                        r7 = heapClassInst.heap32[r5 + numDefine2];
                        r7 = r7 >> numDefine2;
                        heapClassInst.heapFloat[r7 + 1] = f4;
                        r7 = heapClassInst.heap32[r5 + numDefine2];
                        r7 = r7 >> numDefine2;
                        heapClassInst.heapFloat[r7 + numDefine2] = f8;
                        r7 = heapClassInst.heap32[r5 + numDefine2];
                        r7 = (r7 + r9) | 0;
                        r7 = r7 >> numDefine2;
                        heapClassInst.heapFloat[r7] = f16;
                        r7 = heapClassInst.heap32[r5 + numDefine2];
                        r7 = (r7 + r9) | 0;
                        r7 = r7 >> numDefine2;
                        heapClassInst.heapFloat[r7 + 1] = f18;
                        r7 = heapClassInst.heap32[r5 + numDefine2];
                        r7 = (r7 + r9) | 0;
                        r7 = r7 >> numDefine2;
                        heapClassInst.heapFloat[r7 + numDefine2] = f17;
                        r7 = heapClassInst.heap32[r5 + numDefine2];
                        r7 = (r7 + r6) | 0;
                        r7 = r7 >> numDefine2;
                        heapClassInst.heapFloat[r7] = f9;
                        r7 = heapClassInst.heap32[r5 + numDefine2];
                        r7 = (r7 + r10) | 0;
                        r7 = r7 >> numDefine2;
                        heapClassInst.heapFloat[r7] = f10;
                        r7 = heapClassInst.heap32[r5 + numDefine2];
                        r7 = (r7 + r6) | 0;
                        r7 = r7 >> numDefine2;
                        f5 = heapClassInst.heapFloat[fp + numDefineNeg10];
                        f6 = f1 * f5;
                        f7 = heapClassInst.heapFloat[fp + numDefineNeg9];
                        f11 = f4 * f7;
                        heapClassInst.heapFloat[r7 + numDefine2] = f3;
                        f6 = f6 + f11;
                        f11 = heapClassInst.heapFloat[fp + numDefineNeg8];
                        f12 = f8 * f11;
                        r7 = heapClassInst.heap32[r5 + numDefine7];
                        f6 = f6 + f12;
                        r7 = r7 >> numDefine2;
                        f6 = f6 * f0;
                        heapClassInst.heapFloat[r7] = f6;
                        f6 = f16 * f5;
                        f12 = f18 * f7;
                        r7 = heapClassInst.heap32[r5 + numDefine7];
                        f6 = f6 + f12;
                        f12 = f17 * f11;
                        r7 = (r7 + r9) | 0;
                        f6 = f6 + f12;
                        r7 = r7 >> numDefine2;
                        f6 = f6 * f0;
                        heapClassInst.heapFloat[r7] = f6;
                        f5 = f9 * f5;
                        f6 = f10 * f7;
                        r7 = heapClassInst.heap32[r5 + numDefine7];
                        f5 = f5 + f6;
                        f6 = f3 * f11;
                        r6 = (r7 + r6) | 0;
                        f5 = f5 + f6;
                        r6 = r6 >> numDefine2;
                        f0 = f5 * f0;
                        heapClassInst.heapFloat[r6] = f0;
                    }
                    r2 = (r2 + numDefine4) | 0;
                    r6 = (r8 * numDefine3) | 0;
                    r7 = r6 << numDefine2;
                    r9 = heapClassInst.heap32[r5 + numDefine3];
                    r9 = (r9 + r7) | 0;
                    r9 = r9 >> numDefine2;
                    r10 = (r6 + 1) | 0;
                    heapClassInst.heapFloat[r9] = f1;
                    r9 = r10 << numDefine2;
                    r10 = heapClassInst.heap32[r5 + numDefine3];
                    r10 = (r10 + r9) | 0;
                    r10 = r10 >> numDefine2;
                    r6 = (r6 + numDefine2) | 0;
                    heapClassInst.heapFloat[r10] = f4;
                    r6 = r6 << numDefine2;
                    r10 = heapClassInst.heap32[r5 + numDefine3];
                    r10 = (r10 + r6) | 0;
                    r10 = r10 >> numDefine2;
                    heapClassInst.heapFloat[r10] = f8;
                    r8 = r8 << numDefine4;
                    r10 = heapClassInst.heap32[r5 + numDefine3];
                    r10 = (r10 + r8) | 0;
                    r10 = r10 >> numDefine2;
                    heapClassInst.heapFloat[r10] = f16;
                    r10 = r8 | numDefine4;
                    r11 = heapClassInst.heap32[r5 + numDefine3];
                    r11 = (r11 + r10) | 0;
                    r11 = r11 >> numDefine2;
                    heapClassInst.heapFloat[r11] = f18;
                    r11 = r8 | numDefine8;
                    r12 = heapClassInst.heap32[r5 + numDefine3];
                    r12 = (r12 + r11) | 0;
                    r12 = r12 >> numDefine2;
                    heapClassInst.heapFloat[r12] = f17;
                    r12 = heapClassInst.heap32[r5 + numDefine5];
                    r12 = (r12 + r7) | 0;
                    r12 = r12 >> numDefine2;
                    f0 = -f1;
                    heapClassInst.heapFloat[r12] = f0;
                    r12 = heapClassInst.heap32[r5 + numDefine5];
                    r9 = (r12 + r9) | 0;
                    r9 = r9 >> numDefine2;
                    f0 = -f4;
                    heapClassInst.heapFloat[r9] = f0;
                    r9 = heapClassInst.heap32[r5 + numDefine5];
                    r6 = (r9 + r6) | 0;
                    r6 = r6 >> numDefine2;
                    f0 = -f8;
                    heapClassInst.heapFloat[r6] = f0;
                    r6 = heapClassInst.heap32[r5 + numDefine5];
                    r6 = (r6 + r8) | 0;
                    r6 = r6 >> numDefine2;
                    f0 = -f16;
                    heapClassInst.heapFloat[r6] = f0;
                    r6 = heapClassInst.heap32[r5 + numDefine5];
                    r6 = (r6 + r10) | 0;
                    r6 = r6 >> numDefine2;
                    f0 = -f18;
                    heapClassInst.heapFloat[r6] = f0;
                    r6 = heapClassInst.heap32[r5 + numDefine5];
                    r6 = (r6 + r11) | 0;
                    f5 = heapClassInst.heapFloat[fp + numDefineNeg7];
                    f0 = heapClassInst.heapFloat[fp + numDefineNeg2];
                    f6 = f0 * f5;
                    f11 = heapClassInst.heapFloat[fp + numDefineNeg6];
                    f7 = heapClassInst.heapFloat[fp + numDefineNeg3];
                    f12 = f7 * f11;
                    f13 = heapClassInst.heapFloat[fp + numDefineNeg5];
                    f7 = f7 * f13;
                    f14 = heapClassInst.heapFloat[fp + numDefineNeg4];
                    f5 = f14 * f5;
                    f6 = f6 - f12;
                    f5 = f7 - f5;
                    f7 = f14 * f11;
                    f0 = f0 * f13;
                    r6 = r6 >> numDefine2;
                    f11 = -f17;
                    heapClassInst.heapFloat[r6] = f11;
                    f0 = f7 - f0;
                    f1 = f6 * f1;
                    f4 = f5 * f4;
                    r6 = heapClassInst.heap32[r5 + numDefine7];
                    f1 = f1 + f4;
                    f4 = f0 * f8;
                    f7 = heapClassInst.heapFloat[r5];
                    f8 = heapClassInst.heapFloat[r5 + 1];
                    r6 = (r6 + r7) | 0;
                    f1 = f1 + f4;
                    f4 = f7 * f8;
                    r6 = r6 >> numDefine2;
                    f1 = f1 * f4;
                    heapClassInst.heapFloat[r6] = f1;
                    f1 = f6 * f16;
                    f5 = f5 * f18;
                    r6 = heapClassInst.heap32[r5 + numDefine7];
                    f1 = f1 + f5;
                    f0 = f0 * f17;
                    r6 = (r6 + r8) | 0;
                    f0 = f1 + f0;
                    r6 = r6 >> numDefine2;
                    f0 = f0 * f4;
                    heapClassInst.heapFloat[r6] = f0;
                    r6 = heapClassInst.heapU8[r0 + numDefine722];
                    if (r6 != 0) {
                        f0 = heapClassInst.heapFloat[r1 + numDefine176];
                        f1 = heapClassInst.heapFloat[r1 + numDefine179];
                        f0 = f0 * f1;
                        r6 = 1;
                        r7 = numDefine2;
                        r6 = f0 > f2 ? r6 : r7;
                    } else {
                        f0 = 0;
                        r6 = 0;
                    }
                    r7 = heapClassInst.heapU8[r0 + numDefine721];
                    r8 = 0;

                    r9 = r7 != r8 ? 1 : 0;
                    r9 = r9 & 1;
                    r9 = r9 | r6;
                    if (r9 == 0) {
                        label = numDefine54;
                    } else {
                        r9 = heapClassInst.heap32[r5 + numDefine6];
                        r9 = (r9 * numDefine5) | 0;
                        r10 = heapClassInst.heap32[r5 + numDefine3];
                        r11 = r9 << numDefine2;
                        r10 = (r10 + r11) | 0;
                        r10 = r10 >> numDefine2;
                        r12 = (r9 + 1) | 0;
                        heapClassInst.heapFloat[r10] = f9;
                        r10 = r12 << numDefine2;
                        r12 = heapClassInst.heap32[r5 + numDefine3];
                        r12 = (r12 + r10) | 0;
                        r12 = r12 >> numDefine2;
                        r9 = (r9 + numDefine2) | 0;
                        heapClassInst.heapFloat[r12] = f10;
                        r9 = r9 << numDefine2;
                        r12 = heapClassInst.heap32[r5 + numDefine3];
                        r12 = (r12 + r9) | 0;
                        r12 = r12 >> numDefine2;
                        heapClassInst.heapFloat[r12] = f3;
                        r12 = heapClassInst.heap32[r5 + numDefine5];
                        r12 = (r12 + r11) | 0;
                        r12 = r12 >> numDefine2;
                        f1 = -f9;
                        heapClassInst.heapFloat[r12] = f1;
                        r12 = heapClassInst.heap32[r5 + numDefine5];
                        r10 = (r12 + r10) | 0;
                        r10 = r10 >> numDefine2;
                        f1 = -f10;
                        heapClassInst.heapFloat[r10] = f1;
                        r10 = heapClassInst.heap32[r5 + numDefine5];
                        r9 = (r10 + r9) | 0;
                        r9 = r9 >> numDefine2;
                        f1 = -f3;
                        heapClassInst.heapFloat[r9] = f1;
                        r9 = heapClassInst.heap32[r5 + numDefine7];
                        r9 = (r9 + r11) | 0;
                        f1 = heapClassInst.heapFloat[r1 + numDefine172];
                        f4 = heapClassInst.heapFloat[r1 + numDefine173];
                        r9 = r9 >> numDefine2;
                        heapClassInst.heap32[r9] = 0;

                        r9 = r6 != r8 ? 1 : 0;
                        r10 = f1 == f4 ? 1 : 0;
                        r12 = heapClassInst.heap32[r1 + numDefine183];
                        r9 = r9 & r10;
                        r10 = r12 & numDefine2;
                        if (r10 != 0) {
                            r2 = (r0 + numDefine744) | 0;
                        }
                        r2 = r2 >> numDefine2;
                        f5 = heapClassInst.heapFloat[r2];

                        r2 = r7 == r8 ? 1 : 0;
                        r2 = r9 | r2;
                        if (!(r2 != 0)) {
                            r2 = r12 & numDefine4;
                            if (!(r2 == 0)) {
                                r2 = heapClassInst.heap32[r5 + numDefine8];
                                r2 = (r2 + r11) | 0;
                                r2 = r2 >> numDefine2;
                                heapClassInst.heap32[r2] = heapClassInst.heap32[r1 + numDefine184];
                            }
                            f6 = heapClassInst.heapFloat[r1 + numDefine167];
                            repeat94: do {
                                if (f1 < f4) {
                                    f7 = heapClassInst.heapFloat[r1 + numDefine178];
                                    f8 = heapClassInst.heapFloat[r5];
                                    f8 = f8 * f5;
                                    f8 = f6 / f8;
                                    if (f8 >= f2) {
                                        if (f8 > f2) {
                                            if (!(f7 > f4)) {
                                                f2 = f4 - f8;
                                                if (!(f2 >= f7)) {
                                                    f2 = f4 - f7;
                                                    f2 = f2 / f8;
                                                    break repeat94;
                                                }
                                            }
                                            f2 = 0;
                                            f8 = heapClassInst.heapFloat[fp + -1];
                                            f2 = f7 > f4 ? f2 : f8;
                                        } else {
                                            break repeat94;
                                        }
                                    } else {
                                        if (!(f7 < f1)) {
                                            f2 = f1 - f8;
                                            if (!(f2 <= f7)) {
                                                f2 = f1 - f7;
                                                f2 = f2 / f8;
                                                break repeat94;
                                            }
                                        }
                                        f2 = 0;
                                        f8 = heapClassInst.heapFloat[fp + -1];
                                        f2 = f7 < f1 ? f2 : f8;
                                    }
                                } else {
                                    f7 = heapClassInst.heapFloat[fp + -1];
                                    f2 = f1 > f4 ? f7 : f2;
                                }
                            } while (false);
                            r2 = heapClassInst.heap32[r5 + numDefine7];
                            r2 = (r2 + r11) | 0;
                            r2 = r2 >> numDefine2;
                            f2 = f6 * f2;
                            f6 = heapClassInst.heapFloat[r1 + numDefine179];
                            f7 = heapClassInst.heapFloat[r2];
                            f2 = f2 * f6;
                            f2 = f7 + f2;
                            heapClassInst.heapFloat[r2] = f2;
                            r2 = heapClassInst.heap32[r5 + numDefine9];
                            f2 = heapClassInst.heapFloat[r1 + numDefine168];
                            r2 = (r2 + r11) | 0;
                            r2 = r2 >> numDefine2;
                            f2 = -f2;
                            heapClassInst.heapFloat[r2] = f2;
                            r2 = heapClassInst.heap32[r5 + numDefine10];
                            r2 = (r2 + r11) | 0;
                            r2 = r2 >> numDefine2;
                            heapClassInst.heap32[r2] = heapClassInst.heap32[r1 + numDefine168];
                        }
                        if (r6 == 0) {
                            label = numDefine54;
                        } else {
                            r2 = heapClassInst.heap32[r5 + numDefine7];
                            r2 = (r2 + r11) | 0;
                            f2 = heapClassInst.heapFloat[r5];
                            r2 = r2 >> numDefine2;
                            f2 = f2 * f5;
                            f5 = heapClassInst.heapFloat[r2];
                            f0 = f2 * f0;
                            f0 = f5 + f0;
                            heapClassInst.heapFloat[r2] = f0;
                            r0 = heapClassInst.heapU8[r0 + numDefine732];
                            r0 = r0 & 1;
                            if (!(r0 == 0)) {
                                r0 = heapClassInst.heap32[r5 + numDefine8];
                                r0 = (r0 + r11) | 0;
                                r0 = r0 >> numDefine2;
                                heapClassInst.heap32[r0] = heapClassInst.heap32[r1 + numDefine185];
                            }
                            if (f1 != f4) {
                                r0 = heapClassInst.heap32[r5 + numDefine9];
                                if (r6 != 1) {
                                    r0 = (r0 + r11) | 0;
                                    r0 = r0 >> numDefine2;
                                    heapClassInst.heap32[r0] = numDefineNeg88609;
                                    r0 = heapClassInst.heap32[r5 + numDefine10];
                                    r0 = (r0 + r11) | 0;
                                    r0 = r0 >> numDefine2;
                                    heapClassInst.heap32[r0] = 0;
                                } else {
                                    r0 = (r0 + r11) | 0;
                                    r0 = r0 >> numDefine2;
                                    heapClassInst.heap32[r0] = 0;
                                    r0 = heapClassInst.heap32[r5 + numDefine10];
                                    r0 = (r0 + r11) | 0;
                                    r0 = r0 >> numDefine2;
                                    heapClassInst.heap32[r0] = numDefine95039;
                                }
                            } else {
                                r0 = heapClassInst.heap32[r5 + numDefine9];
                                r0 = (r0 + r11) | 0;
                                r0 = r0 >> numDefine2;
                                heapClassInst.heap32[r0] = numDefineNeg88609;
                                r0 = heapClassInst.heap32[r5 + numDefine10];
                                r0 = (r0 + r11) | 0;
                                r0 = r0 >> numDefine2;
                                heapClassInst.heap32[r0] = numDefine95039;
                            }
                            f0 = heapClassInst.heapFloat[r1 + numDefine171];
                            f1 = 0;
                            if (f0 <= f1) {
                                label = numDefine53;
                            } else {
                                f2 = heapClassInst.heapFloat[r4 + numDefine80];
                                f4 = heapClassInst.heapFloat[r3 + numDefine80];
                                f5 = heapClassInst.heapFloat[r4 + numDefine81];
                                f6 = heapClassInst.heapFloat[r3 + numDefine81];
                                f2 = f2 * f9;
                                f5 = f5 * f10;
                                f7 = heapClassInst.heapFloat[r4 + numDefine82];
                                f8 = heapClassInst.heapFloat[r3 + numDefine82];
                                f4 = f4 * f9;
                                f6 = f6 * f10;
                                f2 = f2 + f5;
                                f5 = f7 * f3;
                                f4 = f4 + f6;
                                f3 = f8 * f3;
                                f2 = f2 + f5;
                                f3 = f4 + f3;
                                f2 = f2 - f3;
                                if (r6 != 1) {
                                    if (f2 <= f1) {
                                        label = numDefine53;
                                    } else {
                                        r0 = heapClassInst.heap32[r5 + numDefine7];
                                        f0 = -f0;
                                        r0 = (r0 + r11) | 0;
                                        f0 = f2 * f0;
                                        r0 = r0 >> numDefine2;
                                        f1 = heapClassInst.heapFloat[r0];
                                        if (f1 <= f0) {
                                            label = numDefine53;
                                        } else {
                                            heapClassInst.heapFloat[r0] = f0;
                                            label = numDefine53;
                                        }
                                    }
                                } else {
                                    if (f2 >= f1) {
                                        label = numDefine53;
                                    } else {
                                        r0 = heapClassInst.heap32[r5 + numDefine7];
                                        f0 = -f0;
                                        r0 = (r0 + r11) | 0;
                                        f0 = f2 * f0;
                                        r0 = r0 >> numDefine2;
                                        f1 = heapClassInst.heapFloat[r0];
                                        if (f1 >= f0) {
                                            label = numDefine53;
                                        } else {
                                            heapClassInst.heapFloat[r0] = f0;
                                            label = numDefine53;
                                        }
                                    }
                                }
                            }
                        }
                    }
                } else {
                    r0 = twoEStr1149;
                    r1 = twoEStr231;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine682;
                    assertNew(i7);
                }
            }
        } while (false);
        if (label == numDefine53) {
            r0 = heapClassInst.heap32[r5 + numDefine7];
            r0 = (r0 + r11) | 0;
            r0 = r0 >> numDefine2;
            f0 = heapClassInst.heapFloat[r0];
            f1 = heapClassInst.heapFloat[r1 + numDefine170];
            f0 = f0 * f1;
            heapClassInst.heapFloat[r0] = f0;
        }
        return;
    }

    public static void zn17btHingeConstraint8setParamEifi(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        float f0 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine3];
        if (!(r0 == -1)) {
            if (r0 != numDefine5) {
                r0 = twoEStr10;
                r1 = twoEStr231;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine969;
                assertNew(i7);
            }
        }
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        f0 = heapClassInst.heapFloat[fp + numDefine2];
        if (r1 == numDefine4) {
            r0 = r0 >> numDefine2;
            heapClassInst.heapFloat[r0 + numDefine185] = f0;
            r1 = heapClassInst.heap32[r0 + numDefine183];
            r1 = r1 | 1;
            heapClassInst.heap32[r0 + numDefine183] = r1;
            return;
        } else {
            if (r1 == numDefine3) {
                r0 = r0 >> numDefine2;
                heapClassInst.heapFloat[r0 + numDefine184] = f0;
                r1 = heapClassInst.heap32[r0 + numDefine183];
                r1 = r1 | numDefine4;
                heapClassInst.heap32[r0 + numDefine183] = r1;
                return;
            } else {
                if (r1 != numDefine2) {
                    r0 = twoEStr10;
                    r1 = twoEStr231;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine964;
                    assertNew(i7);
                } else {
                    r0 = r0 >> numDefine2;
                    heapClassInst.heapFloat[r0 + numDefine186] = f0;
                    r1 = heapClassInst.heap32[r0 + numDefine183];
                    r1 = r1 | numDefine2;
                    heapClassInst.heap32[r0 + numDefine183] = r1;
                    return;
                }
            }
        }
    }

    public static void znk17btHingeConstraint8getParamEii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        float f0 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg16;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + numDefine2];
        if (!(r0 == -1)) {
            if (r0 != numDefine5) {
                r0 = twoEStr10;
                r1 = twoEStr231;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine999;
                assertNew(i7);
            }
        }
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + 1];
        if (r1 == numDefine4) {
            r1 = heapClassInst.heapU8[r0 + numDefine732];
            r1 = r1 & 1;
            if (r1 != 0) {
                r0 = (r0 + numDefine740) | 0;
            } else {
                r0 = twoEStr332;
                r1 = twoEStr231;
                heapClassInst.heap32[g0] = r0;
                heapClassInst.heap32[g0 + 1] = r1;
                heapClassInst.heap32[g0 + numDefine2] = numDefine986;
                assertNew(i7);
            }
        } else {
            if (r1 == numDefine3) {
                r1 = heapClassInst.heapU8[r0 + numDefine732];
                r1 = r1 & numDefine4;
                if (r1 != 0) {
                    r0 = (r0 + numDefine736) | 0;
                } else {
                    r0 = twoEStr433;
                    r1 = twoEStr231;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine990;
                    assertNew(i7);
                }
            } else {
                if (r1 != numDefine2) {
                    r0 = twoEStr10;
                    r1 = twoEStr231;
                    heapClassInst.heap32[g0] = r0;
                    heapClassInst.heap32[g0 + 1] = r1;
                    heapClassInst.heap32[g0 + numDefine2] = numDefine994;
                    assertNew(i7);
                } else {
                    r1 = heapClassInst.heapU8[r0 + numDefine732];
                    r1 = r1 & numDefine2;
                    if (r1 != 0) {
                        r0 = (r0 + numDefine744) | 0;
                    } else {
                        r0 = twoEStr130;
                        r1 = twoEStr231;
                        heapClassInst.heap32[g0] = r0;
                        heapClassInst.heap32[g0 + 1] = r1;
                        heapClassInst.heap32[g0 + numDefine2] = numDefine982;
                        assertNew(i7);
                    }
                }
            }
        }
        r0 = r0 >> numDefine2;
        f0 = heapClassInst.heapFloat[r0];
        commonVariable.fg0 = f0;
        return;
    }

    public static void zn17btHingeConstraint13getHingeAngleERK11btTransformS2(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        float f17 = 0.0F;
        float f18 = 0.0F;
        float f19 = 0.0F;
        float f20 = 0.0F;
        float f21 = 0.0F;
        float f22 = 0.0F;
        float f23 = 0.0F;
        float f24 = 0.0F;
        float f25 = 0.0F;
        float f26 = 0.0F;
        float f27 = 0.0F;
        float f28 = 0.0F;
        float f29 = 0.0F;
        float f30 = 0.0F;
        int label = 0;
        i7 = sp + numDefineNeg8;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp + 1];
        r1 = heapClassInst.heap32[fp + numDefine2];
        r2 = heapClassInst.heap32[fp];
        r0 = r0 >> numDefine2;
        r1 = r1 >> numDefine2;
        r2 = r2 >> numDefine2;
        f0 = heapClassInst.heapFloat[r2 + numDefine135];
        f1 = heapClassInst.heapFloat[r0 + numDefine4];
        f2 = heapClassInst.heapFloat[r0];
        f3 = heapClassInst.heapFloat[r2 + numDefine136];
        f4 = heapClassInst.heapFloat[r2 + numDefine139];
        f5 = heapClassInst.heapFloat[r0 + numDefine5];
        f6 = heapClassInst.heapFloat[r0 + 1];
        f7 = heapClassInst.heapFloat[r2 + numDefine140];
        f8 = heapClassInst.heapFloat[r2 + numDefine152];
        f9 = heapClassInst.heapFloat[r1 + numDefine4];
        f10 = heapClassInst.heapFloat[r1];
        f11 = heapClassInst.heapFloat[r2 + numDefine156];
        f12 = heapClassInst.heapFloat[r1 + numDefine5];
        f13 = heapClassInst.heapFloat[r1 + 1];
        f14 = heapClassInst.heapFloat[r0 + numDefine8];
        f15 = heapClassInst.heapFloat[r0 + numDefine9];
        f16 = heapClassInst.heapFloat[r1 + numDefine8];
        f17 = heapClassInst.heapFloat[r1 + numDefine9];
        f18 = f2 * f0;
        f19 = f6 * f4;
        f20 = f1 * f0;
        f21 = f5 * f4;
        f10 = f10 * f8;
        f13 = f13 * f11;
        f2 = f2 * f3;
        f6 = f6 * f7;
        f9 = f9 * f8;
        f12 = f12 * f11;
        f1 = f1 * f3;
        f5 = f5 * f7;
        f22 = heapClassInst.heapFloat[r2 + numDefine143];
        f23 = heapClassInst.heapFloat[r0 + numDefine6];
        f24 = heapClassInst.heapFloat[r0 + numDefine2];
        f25 = heapClassInst.heapFloat[r2 + numDefine144];
        f26 = heapClassInst.heapFloat[r2 + numDefine160];
        f27 = heapClassInst.heapFloat[r1 + numDefine6];
        f28 = heapClassInst.heapFloat[r1 + numDefine2];
        f29 = heapClassInst.heapFloat[r0 + numDefine10];
        f30 = heapClassInst.heapFloat[r1 + numDefine10];
        f18 = f18 + f19;
        f19 = f24 * f22;
        f20 = f20 + f21;
        f21 = f23 * f22;
        f0 = f14 * f0;
        f4 = f15 * f4;
        f10 = f10 + f13;
        f13 = f28 * f26;
        f2 = f2 + f6;
        f6 = f24 * f25;
        f9 = f9 + f12;
        f12 = f27 * f26;
        f1 = f1 + f5;
        f5 = f23 * f25;
        f8 = f16 * f8;
        f11 = f17 * f11;
        f3 = f14 * f3;
        f7 = f15 * f7;
        f14 = f18 + f19;
        f10 = f10 + f13;
        f2 = f2 + f6;
        f6 = f20 + f21;
        f9 = f9 + f12;
        f1 = f1 + f5;
        f0 = f0 + f4;
        f4 = f29 * f22;
        f5 = f8 + f11;
        f8 = f30 * f26;
        f3 = f3 + f7;
        f7 = f29 * f25;
        f11 = f10 * f14;
        f6 = f9 * f6;
        f0 = f0 + f4;
        f4 = f5 + f8;
        f3 = f3 + f7;
        f2 = f10 * f2;
        f1 = f9 * f1;
        f5 = f11 + f6;
        f0 = f4 * f0;
        f1 = f2 + f1;
        f2 = f4 * f3;
        f0 = f5 + f0;
        f1 = f1 + f2;
        heapClassInst.heapFloat[g0] = f0;
        heapClassInst.heapFloat[g0 + 1] = f1;
        atan2f(i7);
        f1 = heapClassInst.heapFloat[r2 + numDefine179];
        f0 = (float) (f1 * commonVariable.fg0);
        commonVariable.fg0 = f0;
        return;
    }

    public static void zn18btConstraintSolver12prepareSolveEii(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        return;
    }

    public static void zn18btConstraintSolver9allSolvedERK19btContactSolverInfoP12btIDebugDrawP12btStackAlloc(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        return;
    }

    public static void zn35btSequentialImpulseConstraintSolver33resolveSingleConstraintRowGenericER11btRigidBodyS1RK18btSolverConstraint(int sp) {
        int i7 = 0;
        int fp = sp >> numDefine2;
        int r0 = 0;
        int r1 = 0;
        int r2 = 0;
        float f0 = 0.0F;
        float f1 = 0.0F;
        float f2 = 0.0F;
        float f3 = 0.0F;
        float f4 = 0.0F;
        float f5 = 0.0F;
        float f6 = 0.0F;
        float f7 = 0.0F;
        float f8 = 0.0F;
        float f9 = 0.0F;
        float f10 = 0.0F;
        float f11 = 0.0F;
        float f12 = 0.0F;
        float f13 = 0.0F;
        float f14 = 0.0F;
        float f15 = 0.0F;
        float f16 = 0.0F;
        int label = 0;
        i7 = sp + 0;
        int g0 = i7 >> numDefine2;
        r0 = heapClassInst.heap32[fp];
        r1 = heapClassInst.heap32[fp + numDefine2];
        r1 = r1 >> numDefine2;
        r0 = r0 >> numDefine2;
        r2 = heapClassInst.heap32[fp + 1];
        r2 = r2 >> numDefine2;
        f0 = heapClassInst.heapFloat[r1 + numDefine4];
        f1 = heapClassInst.heapFloat[r0 + numDefine126];
        f2 = (int) heapClassInst.heapFloat[r1 + numDefine5];
        f3 = heapClassInst.heapFloat[r0 + numDefine127];
        f4 = heapClassInst.heapFloat[r1];
        f5 = heapClassInst.heapFloat[r0 + numDefine130];
        f6 = heapClassInst.heapFloat[r1 + 1];
        f7 = heapClassInst.heapFloat[r0 + numDefine131];
        f8 = heapClassInst.heapFloat[r2 + numDefine126];
        f9 = heapClassInst.heapFloat[r2 + numDefine127];
        f10 = heapClassInst.heapFloat[r1 + numDefine6];
        f11 = heapClassInst.heapFloat[r0 + numDefine128];
        f1 = f0 * f1;
        f3 = f2 * f3;
        f4 = f4 * f5;
        f5 = f6 * f7;
        f6 = heapClassInst.heapFloat[r1 + numDefine2];
        f7 = heapClassInst.heapFloat[r0 + numDefine132];
        f12 = heapClassInst.heapFloat[r1 + numDefine8];
        f13 = heapClassInst.heapFloat[r2 + numDefine130];
        f14 = heapClassInst.heapFloat[r1 + numDefine9];
        f15 = heapClassInst.heapFloat[r2 + numDefine131];
        f16 = heapClassInst.heapFloat[r2 + numDefine128];
        f1 = f1 + f3;
        f3 = f10 * f11;
        f4 = f4 + f5;
        f5 = f6 * f7;
        f6 = f12 * f13;
        f7 = f14 * f15;
        f11 = heapClassInst.heapFloat[r1 + numDefine10];
        f12 = heapClassInst.heapFloat[r2 + numDefine132];
        f8 = f0 * f8;
        f9 = f2 * f9;
        f13 = heapClassInst.heapFloat[r1 + numDefine21];
        f14 = heapClassInst.heapFloat[r1 + numDefine30];
        f1 = f1 + f3;
        f3 = f4 + f5;
        f4 = f6 + f7;
        f5 = f11 * f12;
        f6 = f8 + f9;
        f7 = f10 * f16;
        f8 = heapClassInst.heapFloat[r1 + numDefine29];
        f9 = f13 * f14;
        f1 = f1 + f3;
        f3 = heapClassInst.heapFloat[r1 + numDefine23];
        f4 = f4 + f5;
        f5 = f6 + f7;
        f4 = f4 - f5;
        f5 = f8 - f9;
        f1 = f3 * f1;
        f1 = f5 - f1;
        f3 = f3 * f4;
        f1 = f1 - f3;
        f3 = heapClassInst.heapFloat[r1 + numDefine31];
        f4 = f13 + f1;
        if (f3 <= f4) {
            f3 = heapClassInst.heapFloat[r1 + numDefine32];
            if (f3 >= f4) {
                heapClassInst.heapFloat[r1 + numDefine21] = f4;
            } else {
                f1 = f3 - f13;
                heapClassInst.heapFloat[r1 + numDefine21] = f3;
            }
        } else {
            f1 = f3 - f13;
            heapClassInst.heapFloat[r1 + numDefine21] = f3;
        }
        f3 = heapClassInst.heapFloat[r0 + numDefine84];
        f4 = 0;
        if (!(f3 == f4)) {
            f3 = heapClassInst.heapFloat[r0 + numDefine138];
            f0 = f0 * f3;
            f0 = f0 * f1;
            f3 = heapClassInst.heapFloat[r0 + numDefine126];
            f5 = heapClassInst.heapFloat[r0 + numDefine139];
            f6 = heapClassInst.heapFloat[r0 + numDefine140];
            f0 = f3 + f0;
            f2 = f2 * f5;
            heapClassInst.heapFloat[r0 + numDefine126] = f0;
            f0 = f2 * f1;
            f2 = heapClassInst.heapFloat[r0 + numDefine127];
            f0 = f2 + f0;
            f2 = f10 * f6;
            heapClassInst.heapFloat[r0 + numDefine127] = f0;
            f0 = f2 * f1;
            f2 = heapClassInst.heapFloat[r0 + numDefine128];
            f0 = f2 + f0;
            heapClassInst.heapFloat[r0 + numDefine128] = f0;
            f0 = heapClassInst.heapFloat[r0 + numDefine134];
            f0 = f0 * f1;
            f2 = heapClassInst.heapFloat[r1 + numDefine12];
            f3 = heapClassInst.heapFloat[r0 + numDefine136];
            f5 = heapClassInst.heapFloat[r0 + numDefine135];
            f0 = f2 * f0;
            f2 = heapClassInst.heapFloat[r0 + numDefine130];
            f6 = heapClassInst.heapFloat[r1 + numDefine14];
            f7 = heapClassInst.heapFloat[r1 + numDefine13];
            f0 = f2 + f0;
            f2 = f5 * f1;
            heapClassInst.heapFloat[r0 + numDefine130] = f0;
            f0 = f7 * f2;
            f2 = heapClassInst.heapFloat[r0 + numDefine131];
            f0 = f2 + f0;
            f2 = f3 * f1;
            heapClassInst.heapFloat[r0 + numDefine131] = f0;
            f0 = f6 * f2;
            f2 = heapClassInst.heapFloat[r0 + numDefine132];
            f0 = f2 + f0;
            heapClassInst.heapFloat[r0 + numDefine132] = f0;
        }
        f0 = heapClassInst.heapFloat[r2 + numDefine84];
        if (!(f0 == f4)) {
            f0 = heapClassInst.heapFloat[r1 + numDefine4];
            f2 = heapClassInst.heapFloat[r2 + numDefine138];
            f0 = f2 * f0;
            f0 = f0 * f1;
            f2 = heapClassInst.heapFloat[r2 + numDefine126];
            f3 = heapClassInst.heapFloat[r1 + numDefine5];
            f4 = heapClassInst.heapFloat[r2 + numDefine139];
            f5 = heapClassInst.heapFloat[r1 + numDefine6];
            f6 = heapClassInst.heapFloat[r2 + numDefine140];
            f0 = f2 - f0;
            f2 = f4 * f3;
            heapClassInst.heapFloat[r2 + numDefine126] = f0;
            f0 = f2 * f1;
            f2 = heapClassInst.heapFloat[r2 + numDefine127];
            f0 = f2 - f0;
            f2 = f6 * f5;
            heapClassInst.heapFloat[r2 + numDefine127] = f0;
            f0 = f2 * f1;
            f2 = heapClassInst.heapFloat[r2 + numDefine128];
            f0 = f2 - f0;
            heapClassInst.heapFloat[r2 + numDefine128] = f0;
            f0 = heapClassInst.heapFloat[r2 + numDefine134];
            f0 = f0 * f1;
            f2 = heapClassInst.heapFloat[r1 + numDefine16];
            f3 = heapClassInst.heapFloat[r2 + numDefine136];
            f4 = heapClassInst.heapFloat[r2 + numDefine135];
            f0 = f2 * f0;
            f2 = heapClassInst.heapFloat[r2 + numDefine130];
            f5 = heapClassInst.heapFloat[r1 + numDefine18];
            f6 = heapClassInst.heapFloat[r1 + numDefine17];
            f0 = f2 + f0;
            f2 = f4 * f1;
            heapClassInst.heapFloat[r2 + numDefine130] = f0;
            f0 = f6 * f2;
            f2 = heapClassInst.heapFloat[r2 + numDefine131];
            f0 = f2 + f0;
            f1 = f3 * f1;
            heapClassInst.heapFloat[r2 + numDefine131] = f0;
            f0 = f5 * f1;
            f1 = heapClassInst.heapFloat[r2 + numDefine132];
            f0 = f1 + f0;
            heapClassInst.heapFloat[r2 + numDefine132] = f0;
        }
        return;
    }
}